diff --git a/.github/workflows/notify-downstream.yml b/.github/workflows/notify-downstream.yml new file mode 100644 index 000000000..fa7b2f14e --- /dev/null +++ b/.github/workflows/notify-downstream.yml @@ -0,0 +1,33 @@ +name: Notify Downstream + +on: + push: + branches: + - main + +permissions: + contents: read + +jobs: + notify-downstream: + runs-on: ubuntu-latest + + steps: + - name: Generate GitHub App token + id: app-token + uses: tibdex/github-app-token@v2 + with: + app_id: ${{ secrets.OSS_SYNC_APP_ID }} + private_key: ${{ secrets.OSS_SYNC_APP_PRIVATE_KEY }} + + - name: Notify Repo B + uses: peter-evans/repository-dispatch@v3 + with: + token: ${{ steps.app-token.outputs.token }} + repository: ${{ secrets.OSS_SYNC_DOWNSTREAM_REPO }} + event-type: upstream-commit + client-payload: | + { + "commit_sha": "${{ github.sha }}" + } + diff --git a/README.md b/README.md index a1bf63645..4d563daee 100644 --- a/README.md +++ b/README.md @@ -257,10 +257,14 @@ reporting_task: from crewai import Agent, Crew, Process, Task from crewai.project import CrewBase, agent, crew, task from crewai_tools import SerperDevTool +from crewai.agents.agent_builder.base_agent import BaseAgent +from typing import List @CrewBase class LatestAiDevelopmentCrew(): """LatestAiDevelopment crew""" + agents: List[BaseAgent] + tasks: List[Task] @agent def researcher(self) -> Agent: diff --git a/docs/concepts/agents.mdx b/docs/concepts/agents.mdx index 8f04b9d49..fa954d4fc 100644 --- a/docs/concepts/agents.mdx +++ b/docs/concepts/agents.mdx @@ -118,7 +118,7 @@ class LatestAiDevelopmentCrew(): @agent def researcher(self) -> Agent: return Agent( - config=self.agents_config['researcher'], + config=self.agents_config['researcher'], # type: ignore[index] verbose=True, tools=[SerperDevTool()] ) @@ -126,7 +126,7 @@ class LatestAiDevelopmentCrew(): @agent def reporting_analyst(self) -> Agent: return Agent( - config=self.agents_config['reporting_analyst'], + config=self.agents_config['reporting_analyst'], # type: ignore[index] verbose=True ) ``` diff --git a/docs/concepts/crews.mdx b/docs/concepts/crews.mdx index e5602539a..76268457e 100644 --- a/docs/concepts/crews.mdx +++ b/docs/concepts/crews.mdx @@ -52,12 +52,16 @@ After creating your CrewAI project as outlined in the [Installation](/installati ```python code from crewai import Agent, Crew, Task, Process from crewai.project import CrewBase, agent, task, crew, before_kickoff, after_kickoff - +from crewai.agents.agent_builder.base_agent import BaseAgent +from typing import List @CrewBase class YourCrewName: """Description of your crew""" + agents: List[BaseAgent] + tasks: List[Task] + # Paths to your YAML configuration files # To see an example agent and task defined in YAML, checkout the following: # - Task: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended @@ -80,27 +84,27 @@ class YourCrewName: @agent def agent_one(self) -> Agent: return Agent( - config=self.agents_config['agent_one'], + config=self.agents_config['agent_one'], # type: ignore[index] verbose=True ) @agent def agent_two(self) -> Agent: return Agent( - config=self.agents_config['agent_two'], + config=self.agents_config['agent_two'], # type: ignore[index] verbose=True ) @task def task_one(self) -> Task: return Task( - config=self.tasks_config['task_one'] + config=self.tasks_config['task_one'] # type: ignore[index] ) @task def task_two(self) -> Task: return Task( - config=self.tasks_config['task_two'] + config=self.tasks_config['task_two'] # type: ignore[index] ) @crew diff --git a/docs/concepts/llms.mdx b/docs/concepts/llms.mdx index 2aada5fac..560448f21 100644 --- a/docs/concepts/llms.mdx +++ b/docs/concepts/llms.mdx @@ -438,7 +438,7 @@ In this section, you'll find detailed examples that help you select, configure, @agent def researcher(self) -> Agent: return Agent( - config=self.agents_config['researcher'], + config=self.agents_config['researcher'], # type: ignore[index] llm=local_nvidia_nim_llm ) @@ -535,14 +535,13 @@ In this section, you'll find detailed examples that help you select, configure, Set the following environment variables in your `.env` file: ```toml Code - HUGGINGFACE_API_KEY= + HF_TOKEN= ``` Example usage in your CrewAI project: ```python Code llm = LLM( - model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct", - base_url="your_api_endpoint" + model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct" ) ``` diff --git a/docs/concepts/memory.mdx b/docs/concepts/memory.mdx index 5066db6ed..c375d4898 100644 --- a/docs/concepts/memory.mdx +++ b/docs/concepts/memory.mdx @@ -145,6 +145,7 @@ from crewai.memory import LongTermMemory # Simple memory configuration crew = Crew(memory=True) # Uses default storage locations ``` +Note that External Memory won’t be defined when `memory=True` is set, as we can’t infer which external memory would be suitable for your case ### Custom Storage Configuration ```python @@ -278,15 +279,19 @@ crew = Crew( ### Using External Memory External Memory is a powerful feature that allows you to integrate external memory systems with your CrewAI applications. This is particularly useful when you want to use specialized memory providers or maintain memory across different applications. +Since it’s an external memory, we’re not able to add a default value to it - unlike with Long Term and Short Term memory. #### Basic Usage with Mem0 The most common way to use External Memory is with Mem0 as the provider: ```python +import os from crewai import Agent, Crew, Process, Task from crewai.memory.external.external_memory import ExternalMemory +os.environ["MEM0_API_KEY"] = "YOUR-API-KEY" + agent = Agent( role="You are a helpful assistant", goal="Plan a vacation for the user", @@ -304,7 +309,6 @@ crew = Crew( tasks=[task], verbose=True, process=Process.sequential, - memory=True, external_memory=ExternalMemory( embedder_config={"provider": "mem0", "config": {"user_id": "U-123"}} # you can provide an entire Mem0 configuration ), @@ -363,7 +367,6 @@ crew = Crew( tasks=[task], verbose=True, process=Process.sequential, - memory=True, external_memory=external_memory, ) diff --git a/docs/concepts/tasks.mdx b/docs/concepts/tasks.mdx index 8a0ce74e0..a6eaf59b3 100644 --- a/docs/concepts/tasks.mdx +++ b/docs/concepts/tasks.mdx @@ -113,7 +113,7 @@ class LatestAiDevelopmentCrew(): @agent def researcher(self) -> Agent: return Agent( - config=self.agents_config['researcher'], + config=self.agents_config['researcher'], # type: ignore[index] verbose=True, tools=[SerperDevTool()] ) @@ -121,20 +121,20 @@ class LatestAiDevelopmentCrew(): @agent def reporting_analyst(self) -> Agent: return Agent( - config=self.agents_config['reporting_analyst'], + config=self.agents_config['reporting_analyst'], # type: ignore[index] verbose=True ) @task def research_task(self) -> Task: return Task( - config=self.tasks_config['research_task'] + config=self.tasks_config['research_task'] # type: ignore[index] ) @task def reporting_task(self) -> Task: return Task( - config=self.tasks_config['reporting_task'] + config=self.tasks_config['reporting_task'] # type: ignore[index] ) @crew @@ -288,26 +288,20 @@ To add a guardrail to a task, provide a validation function through the `guardra ```python Code from typing import Tuple, Union, Dict, Any +from crewai import TaskOutput -def validate_blog_content(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]: +def validate_blog_content(result: TaskOutput) -> Tuple[bool, Any]: """Validate blog content meets requirements.""" try: # Check word count word_count = len(result.split()) if word_count > 200: - return (False, { - "error": "Blog content exceeds 200 words", - "code": "WORD_COUNT_ERROR", - "context": {"word_count": word_count} - }) + return (False, "Blog content exceeds 200 words") # Additional validation logic here return (True, result.strip()) except Exception as e: - return (False, { - "error": "Unexpected error during validation", - "code": "SYSTEM_ERROR" - }) + return (False, "Unexpected error during validation") blog_task = Task( description="Write a blog post about AI", @@ -325,29 +319,24 @@ blog_task = Task( - Type hints are recommended but optional 2. **Return Values**: - - Success: Return `(True, validated_result)` - - Failure: Return `(False, error_details)` + - On success: it returns a tuple of `(bool, Any)`. For example: `(True, validated_result)` + - On Failure: it returns a tuple of `(bool, str)`. For example: `(False, "Error message explain the failure")` ### Error Handling Best Practices 1. **Structured Error Responses**: ```python Code -def validate_with_context(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]: +from crewai import TaskOutput + +def validate_with_context(result: TaskOutput) -> Tuple[bool, Any]: try: # Main validation logic validated_data = perform_validation(result) return (True, validated_data) except ValidationError as e: - return (False, { - "error": str(e), - "code": "VALIDATION_ERROR", - "context": {"input": result} - }) + return (False, f"VALIDATION_ERROR: {str(e)}") except Exception as e: - return (False, { - "error": "Unexpected error", - "code": "SYSTEM_ERROR" - }) + return (False, str(e)) ``` 2. **Error Categories**: @@ -358,28 +347,25 @@ def validate_with_context(result: str) -> Tuple[bool, Union[Dict[str, Any], str] 3. **Validation Chain**: ```python Code from typing import Any, Dict, List, Tuple, Union +from crewai import TaskOutput -def complex_validation(result: str) -> Tuple[bool, Union[str, Dict[str, Any]]]: +def complex_validation(result: TaskOutput) -> Tuple[bool, Any]: """Chain multiple validation steps.""" # Step 1: Basic validation if not result: - return (False, {"error": "Empty result", "code": "EMPTY_INPUT"}) + return (False, "Empty result") # Step 2: Content validation try: validated = validate_content(result) if not validated: - return (False, {"error": "Invalid content", "code": "CONTENT_ERROR"}) + return (False, "Invalid content") # Step 3: Format validation formatted = format_output(validated) return (True, formatted) except Exception as e: - return (False, { - "error": str(e), - "code": "VALIDATION_ERROR", - "context": {"step": "content_validation"} - }) + return (False, str(e)) ``` ### Handling Guardrail Results @@ -394,19 +380,16 @@ When a guardrail returns `(False, error)`: Example with retry handling: ```python Code from typing import Optional, Tuple, Union +from crewai import TaskOutput, Task -def validate_json_output(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]: +def validate_json_output(result: TaskOutput) -> Tuple[bool, Any]: """Validate and parse JSON output.""" try: # Try to parse as JSON data = json.loads(result) return (True, data) except json.JSONDecodeError as e: - return (False, { - "error": "Invalid JSON format", - "code": "JSON_ERROR", - "context": {"line": e.lineno, "column": e.colno} - }) + return (False, "Invalid JSON format") task = Task( description="Generate a JSON report", diff --git a/docs/guides/crews/first-crew.mdx b/docs/guides/crews/first-crew.mdx index 8aa384112..8eb2619d1 100644 --- a/docs/guides/crews/first-crew.mdx +++ b/docs/guides/crews/first-crew.mdx @@ -185,15 +185,20 @@ Let's modify the `crew.py` file: from crewai import Agent, Crew, Process, Task from crewai.project import CrewBase, agent, crew, task from crewai_tools import SerperDevTool +from crewai.agents.agent_builder.base_agent import BaseAgent +from typing import List @CrewBase class ResearchCrew(): """Research crew for comprehensive topic analysis and reporting""" + agents: List[BaseAgent] + tasks: List[Task] + @agent def researcher(self) -> Agent: return Agent( - config=self.agents_config['researcher'], + config=self.agents_config['researcher'], # type: ignore[index] verbose=True, tools=[SerperDevTool()] ) @@ -201,20 +206,20 @@ class ResearchCrew(): @agent def analyst(self) -> Agent: return Agent( - config=self.agents_config['analyst'], + config=self.agents_config['analyst'], # type: ignore[index] verbose=True ) @task def research_task(self) -> Task: return Task( - config=self.tasks_config['research_task'] + config=self.tasks_config['research_task'] # type: ignore[index] ) @task def analysis_task(self) -> Task: return Task( - config=self.tasks_config['analysis_task'], + config=self.tasks_config['analysis_task'], # type: ignore[index] output_file='output/report.md' ) @@ -387,4 +392,4 @@ Now that you've built your first crew, you can: Congratulations! You've successfully built your first CrewAI crew that can research and analyze any topic you provide. This foundational experience has equipped you with the skills to create increasingly sophisticated AI systems that can tackle complex, multi-stage problems through collaborative intelligence. - \ No newline at end of file + diff --git a/docs/guides/flows/first-flow.mdx b/docs/guides/flows/first-flow.mdx index cb10de275..d5784f0a9 100644 --- a/docs/guides/flows/first-flow.mdx +++ b/docs/guides/flows/first-flow.mdx @@ -203,35 +203,40 @@ These task definitions provide detailed instructions to our agents, ensuring the # src/guide_creator_flow/crews/content_crew/content_crew.py from crewai import Agent, Crew, Process, Task from crewai.project import CrewBase, agent, crew, task +from crewai.agents.agent_builder.base_agent import BaseAgent +from typing import List @CrewBase class ContentCrew(): """Content writing crew""" + agents: List[BaseAgent] + tasks: List[Task] + @agent def content_writer(self) -> Agent: return Agent( - config=self.agents_config['content_writer'], + config=self.agents_config['content_writer'], # type: ignore[index] verbose=True ) @agent def content_reviewer(self) -> Agent: return Agent( - config=self.agents_config['content_reviewer'], + config=self.agents_config['content_reviewer'], # type: ignore[index] verbose=True ) @task def write_section_task(self) -> Task: return Task( - config=self.tasks_config['write_section_task'] + config=self.tasks_config['write_section_task'] # type: ignore[index] ) @task def review_section_task(self) -> Task: return Task( - config=self.tasks_config['review_section_task'], + config=self.tasks_config['review_section_task'], # type: ignore[index] context=[self.write_section_task()] ) diff --git a/docs/how-to/bring-your-own-agent.mdx b/docs/how-to/bring-your-own-agent.mdx new file mode 100644 index 000000000..3a4e05b54 --- /dev/null +++ b/docs/how-to/bring-your-own-agent.mdx @@ -0,0 +1,443 @@ +--- +title: Bring your own agent +description: Learn how to bring your own agents that work within a Crew. +icon: robots +--- + +Interoperability is a core concept in CrewAI. This guide will show you how to bring your own agents that work within a Crew. + + +## Adapter Guide for Bringing your own agents (Langgraph Agents, OpenAI Agents, etc...) +We require 3 adapters to turn any agent from different frameworks to work within crew. + +1. BaseAgentAdapter +2. BaseToolAdapter +3. BaseConverter + + +## BaseAgentAdapter +This abstract class defines the common interface and functionality that all +agent adapters must implement. It extends BaseAgent to maintain compatibility +with the CrewAI framework while adding adapter-specific requirements. + +Required Methods: + +1. `def configure_tools` +2. `def configure_structured_output` + +## Creating your own Adapter +To integrate an agent from a different framework (e.g., LangGraph, Autogen, OpenAI Assistants) into CrewAI, you need to create a custom adapter by inheriting from `BaseAgentAdapter`. This adapter acts as a compatibility layer, translating between the CrewAI interfaces and the specific requirements of your external agent. + +Here's how you implement your custom adapter: + +1. **Inherit from `BaseAgentAdapter`**: + ```python + from crewai.agents.agent_adapters.base_agent_adapter import BaseAgentAdapter + from crewai.tools import BaseTool + from typing import List, Optional, Any, Dict + + class MyCustomAgentAdapter(BaseAgentAdapter): + # ... implementation details ... + ``` + +2. **Implement `__init__`**: + The constructor should call the parent class constructor `super().__init__(**kwargs)` and perform any initialization specific to your external agent. You can use the optional `agent_config` dictionary passed during CrewAI's `Agent` initialization to configure your adapter and the underlying agent. + + ```python + def __init__(self, agent_config: Optional[Dict[str, Any]] = None, **kwargs: Any): + super().__init__(agent_config=agent_config, **kwargs) + # Initialize your external agent here, possibly using agent_config + # Example: self.external_agent = initialize_my_agent(agent_config) + print(f"Initializing MyCustomAgentAdapter with config: {agent_config}") + ``` + +3. **Implement `configure_tools`**: + This abstract method is crucial. It receives a list of CrewAI `BaseTool` instances. Your implementation must convert or adapt these tools into the format expected by your external agent framework. This might involve wrapping them, extracting specific attributes, or registering them with the external agent instance. + + ```python + def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None: + if tools: + adapted_tools = [] + for tool in tools: + # Adapt CrewAI BaseTool to the format your agent expects + # Example: adapted_tool = adapt_to_my_framework(tool) + # adapted_tools.append(adapted_tool) + pass # Replace with your actual adaptation logic + + # Configure the external agent with the adapted tools + # Example: self.external_agent.set_tools(adapted_tools) + print(f"Configuring tools for MyCustomAgentAdapter: {adapted_tools}") # Placeholder + else: + # Handle the case where no tools are provided + # Example: self.external_agent.set_tools([]) + print("No tools provided for MyCustomAgentAdapter.") + ``` + +4. **Implement `configure_structured_output`**: + This method is called when the CrewAI `Agent` is configured with structured output requirements (e.g., `output_json` or `output_pydantic`). Your adapter needs to ensure the external agent is set up to comply with these requirements. This might involve setting specific parameters on the external agent or ensuring its underlying model supports the requested format. If the external agent doesn't support structured output in a way compatible with CrewAI's expectations, you might need to handle the conversion or raise an appropriate error. + + ```python + def configure_structured_output(self, structured_output: Any) -> None: + # Configure your external agent to produce output in the specified format + # Example: self.external_agent.set_output_format(structured_output) + self.adapted_structured_output = True # Signal that structured output is handled + print(f"Configuring structured output for MyCustomAgentAdapter: {structured_output}") + ``` + +By implementing these methods, your `MyCustomAgentAdapter` will allow your custom agent implementation to function correctly within a CrewAI crew, interacting with tasks and tools seamlessly. Remember to replace the example comments and print statements with your actual adaptation logic specific to the external agent framework you are integrating. + +## BaseToolAdapter implementation +The `BaseToolAdapter` class is responsible for converting CrewAI's native `BaseTool` objects into a format that your specific external agent framework can understand and utilize. Different agent frameworks (like LangGraph, OpenAI Assistants, etc.) have their own unique ways of defining and handling tools, and the `BaseToolAdapter` acts as the translator. + +Here's how you implement your custom tool adapter: + +1. **Inherit from `BaseToolAdapter`**: + ```python + from crewai.agents.agent_adapters.base_tool_adapter import BaseToolAdapter + from crewai.tools import BaseTool + from typing import List, Any + + class MyCustomToolAdapter(BaseToolAdapter): + # ... implementation details ... + ``` + +2. **Implement `configure_tools`**: + This is the core abstract method you must implement. It receives a list of CrewAI `BaseTool` instances provided to the agent. Your task is to iterate through this list, adapt each `BaseTool` into the format expected by your external framework, and store the converted tools in the `self.converted_tools` list (which is initialized in the base class constructor). + + ```python + def configure_tools(self, tools: List[BaseTool]) -> None: + """Configure and convert CrewAI tools for the specific implementation.""" + self.converted_tools = [] # Reset in case it's called multiple times + for tool in tools: + # Sanitize the tool name if required by the target framework + sanitized_name = self.sanitize_tool_name(tool.name) + + # --- Your Conversion Logic Goes Here --- + # Example: Convert BaseTool to a dictionary format for LangGraph + # converted_tool = { + # "name": sanitized_name, + # "description": tool.description, + # "parameters": tool.args_schema.schema() if tool.args_schema else {}, + # # Add any other framework-specific fields + # } + + # Example: Convert BaseTool to an OpenAI function definition + # converted_tool = { + # "type": "function", + # "function": { + # "name": sanitized_name, + # "description": tool.description, + # "parameters": tool.args_schema.schema() if tool.args_schema else {"type": "object", "properties": {}}, + # } + # } + + # --- Replace above examples with your actual adaptation --- + converted_tool = self.adapt_tool_to_my_framework(tool, sanitized_name) # Placeholder + + self.converted_tools.append(converted_tool) + print(f"Adapted tool '{tool.name}' to '{sanitized_name}' for MyCustomToolAdapter") # Placeholder + + print(f"MyCustomToolAdapter finished configuring tools: {len(self.converted_tools)} adapted.") # Placeholder + + # --- Helper method for adaptation (Example) --- + def adapt_tool_to_my_framework(self, tool: BaseTool, sanitized_name: str) -> Any: + # Replace this with the actual logic to convert a CrewAI BaseTool + # to the format needed by your specific external agent framework. + # This will vary greatly depending on the target framework. + adapted_representation = { + "framework_specific_name": sanitized_name, + "framework_specific_description": tool.description, + "inputs": tool.args_schema.schema() if tool.args_schema else None, + "implementation_reference": tool.run # Or however the framework needs to call it + } + # Also ensure the tool works both sync and async + async def async_tool_wrapper(*args, **kwargs): + output = tool.run(*args, **kwargs) + if inspect.isawaitable(output): + return await output + else: + return output + + adapted_tool = MyFrameworkTool( + name=sanitized_name, + description=tool.description, + inputs=tool.args_schema.schema() if tool.args_schema else None, + implementation_reference=async_tool_wrapper + ) + + return adapted_representation + + ``` + +3. **Using the Adapter**: + Typically, you would instantiate your `MyCustomToolAdapter` within your `MyCustomAgentAdapter`'s `configure_tools` method and use it to process the tools before configuring your external agent. + + ```python + # Inside MyCustomAgentAdapter.configure_tools + def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None: + if tools: + tool_adapter = MyCustomToolAdapter() # Instantiate your tool adapter + tool_adapter.configure_tools(tools) # Convert the tools + adapted_tools = tool_adapter.tools() # Get the converted tools + + # Now configure your external agent with the adapted_tools + # Example: self.external_agent.set_tools(adapted_tools) + print(f"Configuring external agent with adapted tools: {adapted_tools}") # Placeholder + else: + # Handle no tools case + print("No tools provided for MyCustomAgentAdapter.") + ``` + +By creating a `BaseToolAdapter`, you decouple the tool conversion logic from the agent adaptation, making the integration cleaner and more modular. Remember to replace the placeholder examples with the actual conversion logic required by your specific external agent framework. + +## BaseConverter +The `BaseConverterAdapter` plays a crucial role when a CrewAI `Task` requires an agent to return its final output in a specific structured format, such as JSON or a Pydantic model. It bridges the gap between CrewAI's structured output requirements and the capabilities of your external agent. + +Its primary responsibilities are: +1. **Configuring the Agent for Structured Output:** Based on the `Task`'s requirements (`output_json` or `output_pydantic`), it instructs the associated `BaseAgentAdapter` (and indirectly, the external agent) on what format is expected. +2. **Enhancing the System Prompt:** It modifies the agent's system prompt to include clear instructions on *how* to generate the output in the required structure. +3. **Post-processing the Result:** It takes the raw output from the agent and attempts to parse, validate, and format it according to the required structure, ultimately returning a string representation (e.g., a JSON string). + +Here's how you implement your custom converter adapter: + +1. **Inherit from `BaseConverterAdapter`**: + ```python + from crewai.agents.agent_adapters.base_converter_adapter import BaseConverterAdapter + # Assuming you have your MyCustomAgentAdapter defined + # from .my_custom_agent_adapter import MyCustomAgentAdapter + from crewai.task import Task + from typing import Any + + class MyCustomConverterAdapter(BaseConverterAdapter): + # Store the expected output type (e.g., 'json', 'pydantic', 'text') + _output_type: str = 'text' + _output_schema: Any = None # Store JSON schema or Pydantic model + + # ... implementation details ... + ``` + +2. **Implement `__init__`**: + The constructor must accept the corresponding `agent_adapter` instance it will work with. + + ```python + def __init__(self, agent_adapter: Any): # Use your specific AgentAdapter type hint + self.agent_adapter = agent_adapter + print(f"Initializing MyCustomConverterAdapter for agent adapter: {type(agent_adapter).__name__}") + ``` + +3. **Implement `configure_structured_output`**: + This method receives the CrewAI `Task` object. You need to check the task's `output_json` and `output_pydantic` attributes to determine the required output structure. Store this information (e.g., in `_output_type` and `_output_schema`) and potentially call configuration methods on your `self.agent_adapter` if the external agent needs specific setup for structured output (which might have been partially handled in the agent adapter's `configure_structured_output` already). + + ```python + def configure_structured_output(self, task: Task) -> None: + """Configure the expected structured output based on the task.""" + if task.output_pydantic: + self._output_type = 'pydantic' + self._output_schema = task.output_pydantic + print(f"Converter: Configured for Pydantic output: {self._output_schema.__name__}") + elif task.output_json: + self._output_type = 'json' + self._output_schema = task.output_json + print(f"Converter: Configured for JSON output with schema: {self._output_schema}") + else: + self._output_type = 'text' + self._output_schema = None + print("Converter: Configured for standard text output.") + + # Optionally, inform the agent adapter if needed + # self.agent_adapter.set_output_mode(self._output_type, self._output_schema) + ``` + +4. **Implement `enhance_system_prompt`**: + This method takes the agent's base system prompt string and should append instructions tailored to the currently configured `_output_type` and `_output_schema`. The goal is to guide the LLM powering the agent to produce output in the correct format. + + ```python + def enhance_system_prompt(self, base_prompt: str) -> str: + """Enhance the system prompt with structured output instructions.""" + if self._output_type == 'text': + return base_prompt # No enhancement needed for plain text + + instructions = "\n\nYour final answer MUST be formatted as " + if self._output_type == 'json': + schema_str = json.dumps(self._output_schema, indent=2) + instructions += f"a JSON object conforming to the following schema:\n```json\n{schema_str}\n```" + elif self._output_type == 'pydantic': + schema_str = json.dumps(self._output_schema.model_json_schema(), indent=2) + instructions += f"a JSON object conforming to the Pydantic model '{self._output_schema.__name__}' with the following schema:\n```json\n{schema_str}\n```" + + instructions += "\nEnsure your entire response is ONLY the valid JSON object, without any introductory text, explanations, or concluding remarks." + + print(f"Converter: Enhancing prompt for {self._output_type} output.") + return base_prompt + instructions + ``` + *Note: The exact prompt engineering might need tuning based on the agent/LLM being used.* + +5. **Implement `post_process_result`**: + This method receives the raw string output from the agent. If structured output was requested (`json` or `pydantic`), you should attempt to parse the string into the expected format. Handle potential parsing errors (e.g., log them, attempt simple fixes, or raise an exception). Crucially, the method must **always return a string**, even if the intermediate format was a dictionary or Pydantic object (e.g., by serializing it back to a JSON string). + + ```python + import json + from pydantic import ValidationError + + def post_process_result(self, result: str) -> str: + """Post-process the agent's result to ensure it matches the expected format.""" + print(f"Converter: Post-processing result for {self._output_type} output.") + if self._output_type == 'json': + try: + # Attempt to parse and re-serialize to ensure validity and consistent format + parsed_json = json.loads(result) + # Optional: Validate against self._output_schema if it's a JSON schema dictionary + # from jsonschema import validate + # validate(instance=parsed_json, schema=self._output_schema) + return json.dumps(parsed_json) + except json.JSONDecodeError as e: + print(f"Error: Failed to parse JSON output: {e}\nRaw output:\n{result}") + # Handle error: return raw, raise exception, or try to fix + return result # Example: return raw output on failure + # except Exception as e: # Catch validation errors if using jsonschema + # print(f"Error: JSON output failed schema validation: {e}\nRaw output:\n{result}") + # return result + elif self._output_type == 'pydantic': + try: + # Attempt to parse into the Pydantic model + model_instance = self._output_schema.model_validate_json(result) + # Return the model serialized back to JSON + return model_instance.model_dump_json() + except ValidationError as e: + print(f"Error: Failed to validate Pydantic output: {e}\nRaw output:\n{result}") + # Handle error + return result # Example: return raw output on failure + except json.JSONDecodeError as e: + print(f"Error: Failed to parse JSON for Pydantic model: {e}\nRaw output:\n{result}") + return result + else: # 'text' + return result # No processing needed for plain text + ``` + +By implementing these methods, your `MyCustomConverterAdapter` ensures that structured output requests from CrewAI tasks are correctly handled by your integrated external agent, improving the reliability and usability of your custom agent within the CrewAI framework. + +## Out of the Box Adapters + +We provide out of the box adapters for the following frameworks: +1. LangGraph +2. OpenAI Agents + +## Kicking off a crew with adapted agents: + +```python +import json +import os +from typing import List + +from crewai_tools import SerperDevTool +from src.crewai import Agent, Crew, Task +from langchain_openai import ChatOpenAI +from pydantic import BaseModel + +from crewai.agents.agent_adapters.langgraph.langgraph_adapter import ( + LangGraphAgentAdapter, +) +from crewai.agents.agent_adapters.openai_agents.openai_adapter import OpenAIAgentAdapter + +# CrewAI Agent +code_helper_agent = Agent( + role="Code Helper", + goal="Help users solve coding problems effectively and provide clear explanations.", + backstory="You are an experienced programmer with deep knowledge across multiple programming languages and frameworks. You specialize in solving complex coding challenges and explaining solutions clearly.", + allow_delegation=False, + verbose=True, +) +# OpenAI Agent Adapter +link_finder_agent = OpenAIAgentAdapter( + role="Link Finder", + goal="Find the most relevant and high-quality resources for coding tasks.", + backstory="You are a research specialist with a talent for finding the most helpful resources. You're skilled at using search tools to discover documentation, tutorials, and examples that directly address the user's coding needs.", + tools=[SerperDevTool()], + allow_delegation=False, + verbose=True, +) + +# LangGraph Agent Adapter +reporter_agent = LangGraphAgentAdapter( + role="Reporter", + goal="Report the results of the tasks.", + backstory="You are a reporter who reports the results of the other tasks", + llm=ChatOpenAI(model="gpt-4o"), + allow_delegation=True, + verbose=True, +) + + +class Code(BaseModel): + code: str + + +task = Task( + description="Give an answer to the coding question: {task}", + expected_output="A thorough answer to the coding question: {task}", + agent=code_helper_agent, + output_json=Code, +) +task2 = Task( + description="Find links to resources that can help with coding tasks. Use the serper tool to find resources that can help.", + expected_output="A list of links to resources that can help with coding tasks", + agent=link_finder_agent, +) + + +class Report(BaseModel): + code: str + links: List[str] + + +task3 = Task( + description="Report the results of the tasks.", + expected_output="A report of the results of the tasks. this is the code produced and then the links to the resources that can help with the coding task.", + agent=reporter_agent, + output_json=Report, +) +# Use in CrewAI +crew = Crew( + agents=[code_helper_agent, link_finder_agent, reporter_agent], + tasks=[task, task2, task3], + verbose=True, +) + +result = crew.kickoff( + inputs={"task": "How do you implement an abstract class in python?"} +) + +# Print raw result first +print("Raw result:", result) + +# Handle result based on its type +if hasattr(result, "json_dict") and result.json_dict: + json_result = result.json_dict + print("\nStructured JSON result:") + print(f"{json.dumps(json_result, indent=2)}") + + # Access fields safely + if isinstance(json_result, dict): + if "code" in json_result: + print("\nCode:") + print( + json_result["code"][:200] + "..." + if len(json_result["code"]) > 200 + else json_result["code"] + ) + + if "links" in json_result: + print("\nLinks:") + for link in json_result["links"][:5]: # Print first 5 links + print(f"- {link}") + if len(json_result["links"]) > 5: + print(f"...and {len(json_result['links']) - 5} more links") +elif hasattr(result, "pydantic") and result.pydantic: + print("\nPydantic model result:") + print(result.pydantic.model_dump_json(indent=2)) +else: + # Fallback to raw output + print("\nNo structured result available, using raw output:") + print(result.raw[:500] + "..." if len(result.raw) > 500 else result.raw) + +``` \ No newline at end of file diff --git a/docs/quickstart.mdx b/docs/quickstart.mdx index 2cbc2df9a..cb01c15cc 100644 --- a/docs/quickstart.mdx +++ b/docs/quickstart.mdx @@ -87,15 +87,20 @@ Follow the steps below to get Crewing! 🚣‍♂️ from crewai import Agent, Crew, Process, Task from crewai.project import CrewBase, agent, crew, task from crewai_tools import SerperDevTool + from crewai.agents.agent_builder.base_agent import BaseAgent + from typing import List @CrewBase class LatestAiDevelopmentCrew(): """LatestAiDevelopment crew""" + agents: List[BaseAgent] + tasks: List[Task] + @agent def researcher(self) -> Agent: return Agent( - config=self.agents_config['researcher'], + config=self.agents_config['researcher'], # type: ignore[index] verbose=True, tools=[SerperDevTool()] ) @@ -103,20 +108,20 @@ Follow the steps below to get Crewing! 🚣‍♂️ @agent def reporting_analyst(self) -> Agent: return Agent( - config=self.agents_config['reporting_analyst'], + config=self.agents_config['reporting_analyst'], # type: ignore[index] verbose=True ) @task def research_task(self) -> Task: return Task( - config=self.tasks_config['research_task'], + config=self.tasks_config['research_task'], # type: ignore[index] ) @task def reporting_task(self) -> Task: return Task( - config=self.tasks_config['reporting_task'], + config=self.tasks_config['reporting_task'], # type: ignore[index] output_file='output/report.md' # This is the file that will be contain the final report. ) diff --git a/docs/tools/jsonsearchtool.mdx b/docs/tools/jsonsearchtool.mdx index d7f8b853e..f7391b92a 100644 --- a/docs/tools/jsonsearchtool.mdx +++ b/docs/tools/jsonsearchtool.mdx @@ -30,7 +30,7 @@ pip install 'crewai[tools]' Here are updated examples on how to utilize the JSONSearchTool effectively for searching within JSON files. These examples take into account the current implementation and usage patterns identified in the codebase. ```python Code -from crewai.json_tools import JSONSearchTool # Updated import path +from crewai_tools import JSONSearchTool # General JSON content search # This approach is suitable when the JSON path is either known beforehand or can be dynamically identified. diff --git a/pyproject.toml b/pyproject.toml index d85c43c93..7528a2ecc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -81,10 +81,10 @@ dev-dependencies = [ "pillow>=10.2.0", "cairosvg>=2.7.1", "pytest>=8.0.0", - "pytest-vcr>=1.0.2", "python-dotenv>=1.0.0", "pytest-asyncio>=0.23.7", "pytest-subprocess>=1.5.2", + "pytest-recording>=0.13.2", ] [project.scripts] diff --git a/src/crewai/agent.py b/src/crewai/agent.py index 4ddd20e21..3fe00c619 100644 --- a/src/crewai/agent.py +++ b/src/crewai/agent.py @@ -156,11 +156,28 @@ class Agent(BaseAgent): except (TypeError, ValueError) as e: raise ValueError(f"Invalid Knowledge Configuration: {str(e)}") + def _is_any_available_memory(self) -> bool: + """Check if any memory is available.""" + if not self.crew: + return False + + memory_attributes = [ + "memory", + "memory_config", + "_short_term_memory", + "_long_term_memory", + "_entity_memory", + "_user_memory", + "_external_memory", + ] + + return any(getattr(self.crew, attr) for attr in memory_attributes) + def execute_task( self, task: Task, context: Optional[str] = None, - tools: Optional[List[BaseTool]] = None, + tools: Optional[List[BaseTool]] = None ) -> str: """Execute a task with the agent. @@ -171,6 +188,11 @@ class Agent(BaseAgent): Returns: Output of the agent + + Raises: + TimeoutError: If execution exceeds the maximum execution time. + ValueError: If the max execution time is not a positive integer. + RuntimeError: If the agent execution fails for other reasons. """ if self.tools_handler: self.tools_handler.last_used_tool = {} # type: ignore # Incompatible types in assignment (expression has type "dict[Never, Never]", variable has type "ToolCalling") @@ -200,7 +222,7 @@ class Agent(BaseAgent): task=task_prompt, context=context ) - if self.crew and self.crew.memory: + if self._is_any_available_memory(): contextual_memory = ContextualMemory( self.crew.memory_config, self.crew._short_term_memory, @@ -247,14 +269,26 @@ class Agent(BaseAgent): task=task, ), ) - result = self.agent_executor.invoke( - { - "input": task_prompt, - "tool_names": self.agent_executor.tools_names, - "tools": self.agent_executor.tools_description, - "ask_for_human_input": task.human_input, - } - )["output"] + + # Determine execution method based on timeout setting + if self.max_execution_time is not None: + if not isinstance(self.max_execution_time, int) or self.max_execution_time <= 0: + raise ValueError("Max Execution time must be a positive integer greater than zero") + result = self._execute_with_timeout(task_prompt, task, self.max_execution_time) + else: + result = self._execute_without_timeout(task_prompt, task) + + except TimeoutError as e: + # Propagate TimeoutError without retry + crewai_event_bus.emit( + self, + event=AgentExecutionErrorEvent( + agent=self, + task=task, + error=str(e), + ), + ) + raise e except Exception as e: if e.__class__.__module__.startswith("litellm"): # Do not retry on litellm errors @@ -295,6 +329,66 @@ class Agent(BaseAgent): ) return result + def _execute_with_timeout( + self, + task_prompt: str, + task: Task, + timeout: int + ) -> str: + """Execute a task with a timeout. + + Args: + task_prompt: The prompt to send to the agent. + task: The task being executed. + timeout: Maximum execution time in seconds. + + Returns: + The output of the agent. + + Raises: + TimeoutError: If execution exceeds the timeout. + RuntimeError: If execution fails for other reasons. + """ + import concurrent.futures + with concurrent.futures.ThreadPoolExecutor() as executor: + future = executor.submit( + self._execute_without_timeout, + task_prompt=task_prompt, + task=task + ) + + try: + return future.result(timeout=timeout) + except concurrent.futures.TimeoutError: + future.cancel() + raise TimeoutError(f"Task '{task.description}' execution timed out after {timeout} seconds. Consider increasing max_execution_time or optimizing the task.") + except Exception as e: + future.cancel() + raise RuntimeError(f"Task execution failed: {str(e)}") + + def _execute_without_timeout( + self, + task_prompt: str, + task: Task + ) -> str: + """Execute a task without a timeout. + + Args: + task_prompt: The prompt to send to the agent. + task: The task being executed. + + Returns: + The output of the agent. + """ + return self.agent_executor.invoke( + { + "input": task_prompt, + "tool_names": self.agent_executor.tools_names, + "tools": self.agent_executor.tools_description, + "ask_for_human_input": task.human_input, + } + )["output"] + def create_agent_executor( self, tools: Optional[List[BaseTool]] = None, task=None ) -> None: @@ -518,6 +612,7 @@ class Agent(BaseAgent): verbose=self.verbose, response_format=response_format, i18n=self.i18n, + original_agent=self, ) return await lite_agent.kickoff_async(messages) diff --git a/src/crewai/agents/agent_adapters/__init__.py b/src/crewai/agents/agent_adapters/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/src/crewai/agents/agent_adapters/base_agent_adapter.py b/src/crewai/agents/agent_adapters/base_agent_adapter.py new file mode 100644 index 000000000..6b8a151d6 --- /dev/null +++ b/src/crewai/agents/agent_adapters/base_agent_adapter.py @@ -0,0 +1,42 @@ +from abc import ABC, abstractmethod +from typing import Any, Dict, List, Optional + +from pydantic import PrivateAttr + +from crewai.agent import BaseAgent +from crewai.tools import BaseTool + + +class BaseAgentAdapter(BaseAgent, ABC): + """Base class for all agent adapters in CrewAI. + + This abstract class defines the common interface and functionality that all + agent adapters must implement. It extends BaseAgent to maintain compatibility + with the CrewAI framework while adding adapter-specific requirements. + """ + + adapted_structured_output: bool = False + _agent_config: Optional[Dict[str, Any]] = PrivateAttr(default=None) + + model_config = {"arbitrary_types_allowed": True} + + def __init__(self, agent_config: Optional[Dict[str, Any]] = None, **kwargs: Any): + super().__init__(adapted_agent=True, **kwargs) + self._agent_config = agent_config + + @abstractmethod + def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None: + """Configure and adapt tools for the specific agent implementation. + + Args: + tools: Optional list of BaseTool instances to be configured + """ + pass + + def configure_structured_output(self, structured_output: Any) -> None: + """Configure the structured output for the specific agent implementation. + + Args: + structured_output: The structured output to be configured + """ + pass diff --git a/src/crewai/agents/agent_adapters/base_converter_adapter.py b/src/crewai/agents/agent_adapters/base_converter_adapter.py new file mode 100644 index 000000000..557e627f3 --- /dev/null +++ b/src/crewai/agents/agent_adapters/base_converter_adapter.py @@ -0,0 +1,29 @@ +from abc import ABC, abstractmethod + + +class BaseConverterAdapter(ABC): + """Base class for all converter adapters in CrewAI. + + This abstract class defines the common interface and functionality that all + converter adapters must implement for converting structured output. + """ + + def __init__(self, agent_adapter): + self.agent_adapter = agent_adapter + + @abstractmethod + def configure_structured_output(self, task) -> None: + """Configure agents to return structured output. + Must support json and pydantic output. + """ + pass + + @abstractmethod + def enhance_system_prompt(self, base_prompt: str) -> str: + """Enhance the system prompt with structured output instructions.""" + pass + + @abstractmethod + def post_process_result(self, result: str) -> str: + """Post-process the result to ensure it matches the expected format: string.""" + pass diff --git a/src/crewai/agents/agent_adapters/base_tool_adapter.py b/src/crewai/agents/agent_adapters/base_tool_adapter.py new file mode 100644 index 000000000..f1ee438a8 --- /dev/null +++ b/src/crewai/agents/agent_adapters/base_tool_adapter.py @@ -0,0 +1,37 @@ +from abc import ABC, abstractmethod +from typing import Any, List, Optional + +from crewai.tools.base_tool import BaseTool + + +class BaseToolAdapter(ABC): + """Base class for all tool adapters in CrewAI. + + This abstract class defines the common interface that all tool adapters + must implement. It provides the structure for adapting CrewAI tools to + different frameworks and platforms. + """ + + original_tools: List[BaseTool] + converted_tools: List[Any] + + def __init__(self, tools: Optional[List[BaseTool]] = None): + self.original_tools = tools or [] + self.converted_tools = [] + + @abstractmethod + def configure_tools(self, tools: List[BaseTool]) -> None: + """Configure and convert tools for the specific implementation. + + Args: + tools: List of BaseTool instances to be configured and converted + """ + pass + + def tools(self) -> List[Any]: + """Return all converted tools.""" + return self.converted_tools + + def sanitize_tool_name(self, tool_name: str) -> str: + """Sanitize tool name for API compatibility.""" + return tool_name.replace(" ", "_") diff --git a/src/crewai/agents/agent_adapters/langgraph/langgraph_adapter.py b/src/crewai/agents/agent_adapters/langgraph/langgraph_adapter.py new file mode 100644 index 000000000..ea2e373d2 --- /dev/null +++ b/src/crewai/agents/agent_adapters/langgraph/langgraph_adapter.py @@ -0,0 +1,226 @@ +from typing import Any, AsyncIterable, Dict, List, Optional + +from pydantic import Field, PrivateAttr + +from crewai.agents.agent_adapters.base_agent_adapter import BaseAgentAdapter +from crewai.agents.agent_adapters.langgraph.langgraph_tool_adapter import ( + LangGraphToolAdapter, +) +from crewai.agents.agent_adapters.langgraph.structured_output_converter import ( + LangGraphConverterAdapter, +) +from crewai.agents.agent_builder.base_agent import BaseAgent +from crewai.tools.agent_tools.agent_tools import AgentTools +from crewai.tools.base_tool import BaseTool +from crewai.utilities import Logger +from crewai.utilities.converter import Converter +from crewai.utilities.events import crewai_event_bus +from crewai.utilities.events.agent_events import ( + AgentExecutionCompletedEvent, + AgentExecutionErrorEvent, + AgentExecutionStartedEvent, +) + +try: + from langchain_core.messages import ToolMessage + from langgraph.checkpoint.memory import MemorySaver + from langgraph.prebuilt import create_react_agent + + LANGGRAPH_AVAILABLE = True +except ImportError: + LANGGRAPH_AVAILABLE = False + + +class LangGraphAgentAdapter(BaseAgentAdapter): + """Adapter for LangGraph agents to work with CrewAI.""" + + model_config = {"arbitrary_types_allowed": True} + + _logger: Logger = PrivateAttr(default_factory=lambda: Logger()) + _tool_adapter: LangGraphToolAdapter = PrivateAttr() + _graph: Any = PrivateAttr(default=None) + _memory: Any = PrivateAttr(default=None) + _max_iterations: int = PrivateAttr(default=10) + function_calling_llm: Any = Field(default=None) + step_callback: Any = Field(default=None) + + model: str = Field(default="gpt-4o") + verbose: bool = Field(default=False) + + def __init__( + self, + role: str, + goal: str, + backstory: str, + tools: Optional[List[BaseTool]] = None, + llm: Any = None, + max_iterations: int = 10, + agent_config: Optional[Dict[str, Any]] = None, + **kwargs, + ): + """Initialize the LangGraph agent adapter.""" + if not LANGGRAPH_AVAILABLE: + raise ImportError( + "LangGraph Agent Dependencies are not installed. Please install it using `uv add langchain-core langgraph`" + ) + super().__init__( + role=role, + goal=goal, + backstory=backstory, + tools=tools, + llm=llm or self.model, + agent_config=agent_config, + **kwargs, + ) + self._tool_adapter = LangGraphToolAdapter(tools=tools) + self._converter_adapter = LangGraphConverterAdapter(self) + self._max_iterations = max_iterations + self._setup_graph() + + def _setup_graph(self) -> None: + """Set up the LangGraph workflow graph.""" + try: + self._memory = MemorySaver() + + converted_tools: List[Any] = self._tool_adapter.tools() + if self._agent_config: + self._graph = create_react_agent( + model=self.llm, + tools=converted_tools, + checkpointer=self._memory, + debug=self.verbose, + **self._agent_config, + ) + else: + self._graph = create_react_agent( + model=self.llm, + tools=converted_tools or [], + checkpointer=self._memory, + debug=self.verbose, + ) + + except ImportError as e: + self._logger.log( + "error", f"Failed to import LangGraph dependencies: {str(e)}" + ) + raise + except Exception as e: + self._logger.log("error", f"Error setting up LangGraph agent: {str(e)}") + raise + + def _build_system_prompt(self) -> str: + """Build a system prompt for the LangGraph agent.""" + base_prompt = f""" + You are {self.role}. + + Your goal is: {self.goal} + + Your backstory: {self.backstory} + + When working on tasks, think step-by-step and use the available tools when necessary. + """ + return self._converter_adapter.enhance_system_prompt(base_prompt) + + def execute_task( + self, + task: Any, + context: Optional[str] = None, + tools: Optional[List[BaseTool]] = None, + ) -> str: + """Execute a task using the LangGraph workflow.""" + self.create_agent_executor(tools) + + self.configure_structured_output(task) + + try: + task_prompt = task.prompt() if hasattr(task, "prompt") else str(task) + + if context: + task_prompt = self.i18n.slice("task_with_context").format( + task=task_prompt, context=context + ) + + crewai_event_bus.emit( + self, + event=AgentExecutionStartedEvent( + agent=self, + tools=self.tools, + task_prompt=task_prompt, + task=task, + ), + ) + + session_id = f"task_{id(task)}" + + config = {"configurable": {"thread_id": session_id}} + + result = self._graph.invoke( + { + "messages": [ + ("system", self._build_system_prompt()), + ("user", task_prompt), + ] + }, + config, + ) + + messages = result.get("messages", []) + last_message = messages[-1] if messages else None + + final_answer = "" + if isinstance(last_message, dict): + final_answer = last_message.get("content", "") + elif hasattr(last_message, "content"): + final_answer = getattr(last_message, "content", "") + + final_answer = ( + self._converter_adapter.post_process_result(final_answer) + or "Task execution completed but no clear answer was provided." + ) + crewai_event_bus.emit( + self, + event=AgentExecutionCompletedEvent( + agent=self, task=task, output=final_answer + ), + ) + + return final_answer + + except Exception as e: + self._logger.log("error", f"Error executing LangGraph task: {str(e)}") + crewai_event_bus.emit( + self, + event=AgentExecutionErrorEvent( + agent=self, + task=task, + error=str(e), + ), + ) + raise + + def create_agent_executor(self, tools: Optional[List[BaseTool]] = None) -> None: + """Configure the LangGraph agent for execution.""" + self.configure_tools(tools) + + def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None: + """Configure tools for the LangGraph agent.""" + if tools: + all_tools = list(self.tools or []) + list(tools or []) + self._tool_adapter.configure_tools(all_tools) + available_tools = self._tool_adapter.tools() + self._graph.tools = available_tools + + def get_delegation_tools(self, agents: List[BaseAgent]) -> List[BaseTool]: + """Implement delegation tools support for LangGraph.""" + agent_tools = AgentTools(agents=agents) + return agent_tools.tools() + + def get_output_converter( + self, llm: Any, text: str, model: Any, instructions: str + ) -> Any: + """Convert output format if needed.""" + return Converter(llm=llm, text=text, model=model, instructions=instructions) + + def configure_structured_output(self, task) -> None: + """Configure the structured output for LangGraph.""" + self._converter_adapter.configure_structured_output(task) diff --git a/src/crewai/agents/agent_adapters/langgraph/langgraph_tool_adapter.py b/src/crewai/agents/agent_adapters/langgraph/langgraph_tool_adapter.py new file mode 100644 index 000000000..0bc31d201 --- /dev/null +++ b/src/crewai/agents/agent_adapters/langgraph/langgraph_tool_adapter.py @@ -0,0 +1,61 @@ +import inspect +from typing import Any, List, Optional + +from crewai.agents.agent_adapters.base_tool_adapter import BaseToolAdapter +from crewai.tools.base_tool import BaseTool + + +class LangGraphToolAdapter(BaseToolAdapter): + """Adapts CrewAI tools to LangGraph agent tool compatible format""" + + def __init__(self, tools: Optional[List[BaseTool]] = None): + self.original_tools = tools or [] + self.converted_tools = [] + + def configure_tools(self, tools: List[BaseTool]) -> None: + """ + Configure and convert CrewAI tools to LangGraph-compatible format. + LangGraph expects tools in langchain_core.tools format. + """ + from langchain_core.tools import BaseTool, StructuredTool + + converted_tools = [] + if self.original_tools: + all_tools = tools + self.original_tools + else: + all_tools = tools + for tool in all_tools: + if isinstance(tool, BaseTool): + converted_tools.append(tool) + continue + + sanitized_name = self.sanitize_tool_name(tool.name) + + async def tool_wrapper(*args, tool=tool, **kwargs): + output = None + if len(args) > 0 and isinstance(args[0], str): + output = tool.run(args[0]) + elif "input" in kwargs: + output = tool.run(kwargs["input"]) + else: + output = tool.run(**kwargs) + + if inspect.isawaitable(output): + result = await output + else: + result = output + return result + + converted_tool = StructuredTool( + name=sanitized_name, + description=tool.description, + func=tool_wrapper, + args_schema=tool.args_schema, + ) + + converted_tools.append(converted_tool) + + self.converted_tools = converted_tools + + def tools(self) -> List[Any]: + return self.converted_tools or [] diff --git a/src/crewai/agents/agent_adapters/langgraph/structured_output_converter.py b/src/crewai/agents/agent_adapters/langgraph/structured_output_converter.py new file mode 100644 index 000000000..79f6dcb15 --- /dev/null +++ b/src/crewai/agents/agent_adapters/langgraph/structured_output_converter.py @@ -0,0 +1,80 @@ +import json + +from crewai.agents.agent_adapters.base_converter_adapter import BaseConverterAdapter +from crewai.utilities.converter import generate_model_description + + +class LangGraphConverterAdapter(BaseConverterAdapter): + """Adapter for handling structured output conversion in LangGraph agents""" + + def __init__(self, agent_adapter): + """Initialize the converter adapter with a reference to the agent adapter""" + self.agent_adapter = agent_adapter + self._output_format = None + self._schema = None + self._system_prompt_appendix = None + + def configure_structured_output(self, task) -> None: + """Configure the structured output for LangGraph.""" + if not (task.output_json or task.output_pydantic): + self._output_format = None + self._schema = None + self._system_prompt_appendix = None + return + + if task.output_json: + self._output_format = "json" + self._schema = generate_model_description(task.output_json) + elif task.output_pydantic: + self._output_format = "pydantic" + self._schema = generate_model_description(task.output_pydantic) + + self._system_prompt_appendix = self._generate_system_prompt_appendix() + + def _generate_system_prompt_appendix(self) -> str: + """Generate an appendix for the system prompt to enforce structured output""" + if not self._output_format or not self._schema: + return "" + + return f""" +Important: Your final answer MUST be provided in the following structured format: + +{self._schema} + +DO NOT include any markdown code blocks, backticks, or other formatting around your response. +The output should be raw JSON that exactly matches the specified schema. +""" + + def enhance_system_prompt(self, original_prompt: str) -> str: + """Add structured output instructions to the system prompt if needed""" + if not self._system_prompt_appendix: + return original_prompt + + return f"{original_prompt}\n{self._system_prompt_appendix}" + + def post_process_result(self, result: str) -> str: + """Post-process the result to ensure it matches the expected format""" + if not self._output_format: + return result + + # Try to extract valid JSON if it's wrapped in code blocks or other text + if self._output_format in ["json", "pydantic"]: + try: + # First, try to parse as is + json.loads(result) + return result + except json.JSONDecodeError: + # Try to extract JSON from the text + import re + + json_match = re.search(r"(\{.*\})", result, re.DOTALL) + if json_match: + try: + extracted = json_match.group(1) + # Validate it's proper JSON + json.loads(extracted) + return extracted + except: + pass + + return result diff --git a/src/crewai/agents/agent_adapters/openai_agents/openai_adapter.py b/src/crewai/agents/agent_adapters/openai_agents/openai_adapter.py new file mode 100644 index 000000000..ac368c1a3 --- /dev/null +++ b/src/crewai/agents/agent_adapters/openai_agents/openai_adapter.py @@ -0,0 +1,178 @@ +from typing import Any, List, Optional + +from pydantic import Field, PrivateAttr + +from crewai.agents.agent_adapters.base_agent_adapter import BaseAgentAdapter +from crewai.agents.agent_adapters.openai_agents.structured_output_converter import ( + OpenAIConverterAdapter, +) +from crewai.agents.agent_builder.base_agent import BaseAgent +from crewai.tools import BaseTool +from crewai.tools.agent_tools.agent_tools import AgentTools +from crewai.utilities import Logger +from crewai.utilities.events import crewai_event_bus +from crewai.utilities.events.agent_events import ( + AgentExecutionCompletedEvent, + AgentExecutionErrorEvent, + AgentExecutionStartedEvent, +) + +try: + from agents import Agent as OpenAIAgent # type: ignore + from agents import Runner, enable_verbose_stdout_logging # type: ignore + + from .openai_agent_tool_adapter import OpenAIAgentToolAdapter + + OPENAI_AVAILABLE = True +except ImportError: + OPENAI_AVAILABLE = False + + +class OpenAIAgentAdapter(BaseAgentAdapter): + """Adapter for OpenAI Assistants""" + + model_config = {"arbitrary_types_allowed": True} + + _openai_agent: "OpenAIAgent" = PrivateAttr() + _logger: Logger = PrivateAttr(default_factory=lambda: Logger()) + _active_thread: Optional[str] = PrivateAttr(default=None) + function_calling_llm: Any = Field(default=None) + step_callback: Any = Field(default=None) + _tool_adapter: "OpenAIAgentToolAdapter" = PrivateAttr() + _converter_adapter: OpenAIConverterAdapter = PrivateAttr() + + def __init__( + self, + model: str = "gpt-4o-mini", + tools: Optional[List[BaseTool]] = None, + agent_config: Optional[dict] = None, + **kwargs, + ): + if not OPENAI_AVAILABLE: + raise ImportError( + "OpenAI Agent Dependencies are not installed. Please install it using `uv add openai-agents`" + ) + else: + role = kwargs.pop("role", None) + goal = kwargs.pop("goal", None) + backstory = kwargs.pop("backstory", None) + super().__init__( + role=role, + goal=goal, + backstory=backstory, + tools=tools, + agent_config=agent_config, + **kwargs, + ) + self._tool_adapter = OpenAIAgentToolAdapter(tools=tools) + self.llm = model + self._converter_adapter = OpenAIConverterAdapter(self) + + def _build_system_prompt(self) -> str: + """Build a system prompt for the OpenAI agent.""" + base_prompt = f""" + You are {self.role}. + + Your goal is: {self.goal} + + Your backstory: {self.backstory} + + When working on tasks, think step-by-step and use the available tools when necessary. + """ + return self._converter_adapter.enhance_system_prompt(base_prompt) + + def execute_task( + self, + task: Any, + context: Optional[str] = None, + tools: Optional[List[BaseTool]] = None, + ) -> str: + """Execute a task using the OpenAI Assistant""" + self._converter_adapter.configure_structured_output(task) + self.create_agent_executor(tools) + + if self.verbose: + enable_verbose_stdout_logging() + + try: + task_prompt = task.prompt() + if context: + task_prompt = self.i18n.slice("task_with_context").format( + task=task_prompt, context=context + ) + crewai_event_bus.emit( + self, + event=AgentExecutionStartedEvent( + agent=self, + tools=self.tools, + task_prompt=task_prompt, + task=task, + ), + ) + result = self.agent_executor.run_sync(self._openai_agent, task_prompt) + final_answer = self.handle_execution_result(result) + crewai_event_bus.emit( + self, + event=AgentExecutionCompletedEvent( + agent=self, task=task, output=final_answer + ), + ) + return final_answer + + except Exception as e: + self._logger.log("error", f"Error executing OpenAI task: {str(e)}") + crewai_event_bus.emit( + self, + event=AgentExecutionErrorEvent( + agent=self, + task=task, + error=str(e), + ), + ) + raise + + def create_agent_executor(self, tools: Optional[List[BaseTool]] = None) -> None: + """ + Configure the OpenAI agent for execution. + While OpenAI handles execution differently through Runner, + we can use this method to set up tools and configurations. + """ + all_tools = list(self.tools or []) + list(tools or []) + + instructions = self._build_system_prompt() + self._openai_agent = OpenAIAgent( + name=self.role, + instructions=instructions, + model=self.llm, + **self._agent_config or {}, + ) + + if all_tools: + self.configure_tools(all_tools) + + self.agent_executor = Runner + + def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None: + """Configure tools for the OpenAI Assistant""" + if tools: + self._tool_adapter.configure_tools(tools) + if self._tool_adapter.converted_tools: + self._openai_agent.tools = self._tool_adapter.converted_tools + + def handle_execution_result(self, result: Any) -> str: + """Process OpenAI Assistant execution result converting any structured output to a string""" + return self._converter_adapter.post_process_result(result.final_output) + + def get_delegation_tools(self, agents: List[BaseAgent]) -> List[BaseTool]: + """Implement delegation tools support""" + agent_tools = AgentTools(agents=agents) + tools = agent_tools.tools() + return tools + + def configure_structured_output(self, task) -> None: + """Configure the structured output for the specific agent implementation. + + Args: + structured_output: The structured output to be configured + """ + self._converter_adapter.configure_structured_output(task) diff --git a/src/crewai/agents/agent_adapters/openai_agents/openai_agent_tool_adapter.py b/src/crewai/agents/agent_adapters/openai_agents/openai_agent_tool_adapter.py new file mode 100644 index 000000000..92eeb7b00 --- /dev/null +++ b/src/crewai/agents/agent_adapters/openai_agents/openai_agent_tool_adapter.py @@ -0,0 +1,91 @@ +import inspect +from typing import Any, List, Optional + +from agents import FunctionTool, Tool + +from crewai.agents.agent_adapters.base_tool_adapter import BaseToolAdapter +from crewai.tools import BaseTool + + +class OpenAIAgentToolAdapter(BaseToolAdapter): + """Adapter for OpenAI Assistant tools""" + + def __init__(self, tools: Optional[List[BaseTool]] = None): + self.original_tools = tools or [] + + def configure_tools(self, tools: List[BaseTool]) -> None: + """Configure tools for the OpenAI Assistant""" + if self.original_tools: + all_tools = tools + self.original_tools + else: + all_tools = tools + if all_tools: + self.converted_tools = self._convert_tools_to_openai_format(all_tools) + + def _convert_tools_to_openai_format( + self, tools: Optional[List[BaseTool]] + ) -> List[Tool]: + """Convert CrewAI tools to OpenAI Assistant tool format""" + if not tools: + return [] + + def sanitize_tool_name(name: str) -> str: + """Convert tool name to match OpenAI's required pattern""" + import re + + sanitized = re.sub(r"[^a-zA-Z0-9_-]", "_", name).lower() + return sanitized + + def create_tool_wrapper(tool: BaseTool): + """Create a wrapper function that handles the OpenAI function tool interface""" + + async def wrapper(context_wrapper: Any, arguments: Any) -> Any: + # Get the parameter name from the schema + param_name = list( + tool.args_schema.model_json_schema()["properties"].keys() + )[0] + + # Handle different argument types + if isinstance(arguments, dict): + args_dict = arguments + elif isinstance(arguments, str): + try: + import json + + args_dict = json.loads(arguments) + except json.JSONDecodeError: + args_dict = {param_name: arguments} + else: + args_dict = {param_name: str(arguments)} + + # Run the tool with the processed arguments + output = tool._run(**args_dict) + + # Await if the tool returned a coroutine + if inspect.isawaitable(output): + result = await output + else: + result = output + + # Ensure the result is JSON serializable + if isinstance(result, (dict, list, str, int, float, bool, type(None))): + return result + return str(result) + + return wrapper + + openai_tools = [] + for tool in tools: + schema = tool.args_schema.model_json_schema() + + schema.update({"additionalProperties": False, "type": "object"}) + + openai_tool = FunctionTool( + name=sanitize_tool_name(tool.name), + description=tool.description, + params_json_schema=schema, + on_invoke_tool=create_tool_wrapper(tool), + ) + openai_tools.append(openai_tool) + + return openai_tools diff --git a/src/crewai/agents/agent_adapters/openai_agents/structured_output_converter.py b/src/crewai/agents/agent_adapters/openai_agents/structured_output_converter.py new file mode 100644 index 000000000..252374bf0 --- /dev/null +++ b/src/crewai/agents/agent_adapters/openai_agents/structured_output_converter.py @@ -0,0 +1,122 @@ +import json +import re + +from crewai.agents.agent_adapters.base_converter_adapter import BaseConverterAdapter +from crewai.utilities.converter import generate_model_description +from crewai.utilities.i18n import I18N + + +class OpenAIConverterAdapter(BaseConverterAdapter): + """ + Adapter for handling structured output conversion in OpenAI agents. + + This adapter enhances the OpenAI agent to handle structured output formats + and post-processes the results when needed. + + Attributes: + _output_format: The expected output format (json, pydantic, or None) + _schema: The schema description for the expected output + _output_model: The Pydantic model for the output + """ + + def __init__(self, agent_adapter): + """Initialize the converter adapter with a reference to the agent adapter""" + self.agent_adapter = agent_adapter + self._output_format = None + self._schema = None + self._output_model = None + + def configure_structured_output(self, task) -> None: + """ + Configure the structured output for OpenAI agent based on task requirements. + + Args: + task: The task containing output format requirements + """ + # Reset configuration + self._output_format = None + self._schema = None + self._output_model = None + + # If no structured output is required, return early + if not (task.output_json or task.output_pydantic): + return + + # Configure based on task output format + if task.output_json: + self._output_format = "json" + self._schema = generate_model_description(task.output_json) + self.agent_adapter._openai_agent.output_type = task.output_json + self._output_model = task.output_json + elif task.output_pydantic: + self._output_format = "pydantic" + self._schema = generate_model_description(task.output_pydantic) + self.agent_adapter._openai_agent.output_type = task.output_pydantic + self._output_model = task.output_pydantic + + def enhance_system_prompt(self, base_prompt: str) -> str: + """ + Enhance the base system prompt with structured output requirements if needed. + + Args: + base_prompt: The original system prompt + + Returns: + Enhanced system prompt with output format instructions if needed + """ + if not self._output_format: + return base_prompt + + output_schema = ( + I18N() + .slice("formatted_task_instructions") + .format(output_format=self._schema) + ) + + return f"{base_prompt}\n\n{output_schema}" + + def post_process_result(self, result: str) -> str: + """ + Post-process the result to ensure it matches the expected format. + + This method attempts to extract valid JSON from the result if necessary. + + Args: + result: The raw result from the agent + + Returns: + Processed result conforming to the expected output format + """ + if not self._output_format: + return result + # Try to extract valid JSON if it's wrapped in code blocks or other text + if isinstance(result, str) and self._output_format in ["json", "pydantic"]: + # First, try to parse as is + try: + json.loads(result) + return result + except json.JSONDecodeError: + # Try to extract JSON from markdown code blocks + code_block_pattern = r"```(?:json)?\s*([\s\S]*?)```" + code_blocks = re.findall(code_block_pattern, result) + + for block in code_blocks: + try: + json.loads(block.strip()) + return block.strip() + except json.JSONDecodeError: + continue + + # Try to extract any JSON-like structure + json_pattern = r"(\{[\s\S]*\})" + json_matches = re.findall(json_pattern, result, re.DOTALL) + + for match in json_matches: + try: + json.loads(match) + return match + except json.JSONDecodeError: + continue + + # If all extraction attempts fail, return the original + return str(result) diff --git a/src/crewai/agents/agent_builder/base_agent.py b/src/crewai/agents/agent_builder/base_agent.py index f11c74ae1..a82cd12d7 100644 --- a/src/crewai/agents/agent_builder/base_agent.py +++ b/src/crewai/agents/agent_builder/base_agent.py @@ -62,8 +62,6 @@ class BaseAgent(ABC, BaseModel): Abstract method to execute a task. create_agent_executor(tools=None) -> None: Abstract method to create an agent executor. - _parse_tools(tools: List[BaseTool]) -> List[Any]: - Abstract method to parse tools. get_delegation_tools(agents: List["BaseAgent"]): Abstract method to set the agents task tools for handling delegation and question asking to other agents in crew. get_output_converter(llm, model, instructions): @@ -154,6 +152,9 @@ class BaseAgent(ABC, BaseModel): callbacks: List[Callable] = Field( default=[], description="Callbacks to be used for the agent" ) + adapted_agent: bool = Field( + default=False, description="Whether the agent is adapted" + ) @model_validator(mode="before") @classmethod @@ -170,15 +171,15 @@ class BaseAgent(ABC, BaseModel): 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 = [] + required_attrs = ["name", "func", "description"] for tool in tools: if isinstance(tool, BaseTool): processed_tools.append(tool) - elif ( - hasattr(tool, "name") - and hasattr(tool, "func") - and hasattr(tool, "description") - ): + elif all(hasattr(tool, attr) for attr in required_attrs): # Tool has the required attributes, create a Tool instance processed_tools.append(Tool.from_langchain(tool)) else: @@ -260,13 +261,6 @@ class BaseAgent(ABC, BaseModel): """Set the task tools that init BaseAgenTools class.""" pass - @abstractmethod - def get_output_converter( - self, llm: Any, text: str, model: type[BaseModel] | None, instructions: str - ) -> Converter: - """Get the converter class for the agent to create json/pydantic outputs.""" - pass - def copy(self: T) -> T: # type: ignore # Signature of "copy" incompatible with supertype "BaseModel" """Create a deep copy of the Agent.""" exclude = { diff --git a/src/crewai/agents/agent_builder/base_agent_executor_mixin.py b/src/crewai/agents/agent_builder/base_agent_executor_mixin.py index 185d34d04..c46c46844 100644 --- a/src/crewai/agents/agent_builder/base_agent_executor_mixin.py +++ b/src/crewai/agents/agent_builder/base_agent_executor_mixin.py @@ -72,7 +72,6 @@ class CrewAgentExecutorMixin: """Create and save long-term and entity memory items based on evaluation.""" if ( self.crew - and self.crew.memory and self.crew._long_term_memory and self.crew._entity_memory and self.task @@ -114,6 +113,15 @@ class CrewAgentExecutorMixin: except Exception as e: print(f"Failed to add to long term memory: {e}") pass + elif ( + self.crew + and self.crew._long_term_memory + and self.crew._entity_memory is None + ): + self._printer.print( + content="Long term memory is enabled, but entity memory is not enabled. Please configure entity memory or set memory=True to automatically enable it.", + color="bold_yellow", + ) def _ask_human_input(self, final_answer: str) -> str: """Prompt human input with mode-appropriate messaging.""" diff --git a/src/crewai/cli/constants.py b/src/crewai/cli/constants.py index fec0b6384..2e7ed3728 100644 --- a/src/crewai/cli/constants.py +++ b/src/crewai/cli/constants.py @@ -91,6 +91,12 @@ ENV_VARS = { "key_name": "CEREBRAS_API_KEY", }, ], + "huggingface": [ + { + "prompt": "Enter your Huggingface API key (HF_TOKEN) (press Enter to skip)", + "key_name": "HF_TOKEN", + }, + ], "sambanova": [ { "prompt": "Enter your SambaNovaCloud API key (press Enter to skip)", @@ -106,6 +112,7 @@ PROVIDERS = [ "gemini", "nvidia_nim", "groq", + "huggingface", "ollama", "watson", "bedrock", @@ -270,6 +277,12 @@ MODELS = { "bedrock/mistral.mistral-7b-instruct-v0:2", "bedrock/mistral.mixtral-8x7b-instruct-v0:1", ], + "huggingface": [ + "huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct", + "huggingface/mistralai/Mixtral-8x7B-Instruct-v0.1", + "huggingface/tiiuae/falcon-180B-chat", + "huggingface/google/gemma-7b-it", + ], "sambanova": [ "sambanova/Meta-Llama-3.3-70B-Instruct", "sambanova/QwQ-32B-Preview", diff --git a/src/crewai/cli/templates/crew/crew.py b/src/crewai/cli/templates/crew/crew.py index 700f97c07..43a2608a4 100644 --- a/src/crewai/cli/templates/crew/crew.py +++ b/src/crewai/cli/templates/crew/crew.py @@ -1,6 +1,7 @@ from crewai import Agent, Crew, Process, Task from crewai.project import CrewBase, agent, crew, task - +from crewai.agents.agent_builder.base_agent import BaseAgent +from typing import List # If you want to run a snippet of code before or after the crew starts, # you can use the @before_kickoff and @after_kickoff decorators # https://docs.crewai.com/concepts/crews#example-crew-class-with-decorators @@ -9,25 +10,26 @@ from crewai.project import CrewBase, agent, crew, task class {{crew_name}}(): """{{crew_name}} crew""" + agents: List[BaseAgent] + tasks: List[Task] + # Learn more about YAML configuration files here: # Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended # Tasks: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended - agents_config = 'config/agents.yaml' - tasks_config = 'config/tasks.yaml' - + # If you would like to add tools to your agents, you can learn more about it here: # https://docs.crewai.com/concepts/agents#agent-tools @agent def researcher(self) -> Agent: return Agent( - config=self.agents_config['researcher'], + config=self.agents_config['researcher'], # type: ignore[index] verbose=True ) @agent def reporting_analyst(self) -> Agent: return Agent( - config=self.agents_config['reporting_analyst'], + config=self.agents_config['reporting_analyst'], # type: ignore[index] verbose=True ) @@ -37,13 +39,13 @@ class {{crew_name}}(): @task def research_task(self) -> Task: return Task( - config=self.tasks_config['research_task'], + config=self.tasks_config['research_task'], # type: ignore[index] ) @task def reporting_task(self) -> Task: return Task( - config=self.tasks_config['reporting_task'], + config=self.tasks_config['reporting_task'], # type: ignore[index] output_file='report.md' ) diff --git a/src/crewai/cli/templates/crew/main.py b/src/crewai/cli/templates/crew/main.py index 454d28ee6..b604d8ceb 100644 --- a/src/crewai/cli/templates/crew/main.py +++ b/src/crewai/cli/templates/crew/main.py @@ -33,7 +33,8 @@ def train(): Train the crew for a given number of iterations. """ inputs = { - "topic": "AI LLMs" + "topic": "AI LLMs", + 'current_year': str(datetime.now().year) } try: {{crew_name}}().crew().train(n_iterations=int(sys.argv[1]), filename=sys.argv[2], inputs=inputs) @@ -59,6 +60,7 @@ def test(): "topic": "AI LLMs", "current_year": str(datetime.now().year) } + try: {{crew_name}}().crew().test(n_iterations=int(sys.argv[1]), eval_llm=sys.argv[2], inputs=inputs) diff --git a/src/crewai/cli/templates/flow/crews/poem_crew/poem_crew.py b/src/crewai/cli/templates/flow/crews/poem_crew/poem_crew.py index 5e978d985..1f2a81466 100644 --- a/src/crewai/cli/templates/flow/crews/poem_crew/poem_crew.py +++ b/src/crewai/cli/templates/flow/crews/poem_crew/poem_crew.py @@ -1,5 +1,7 @@ from crewai import Agent, Crew, Process, Task from crewai.project import CrewBase, agent, crew, task +from crewai.agents.agent_builder.base_agent import BaseAgent +from typing import List # If you want to run a snippet of code before or after the crew starts, # you can use the @before_kickoff and @after_kickoff decorators @@ -10,6 +12,9 @@ from crewai.project import CrewBase, agent, crew, task class PoemCrew: """Poem Crew""" + agents: List[BaseAgent] + tasks: List[Task] + # Learn more about YAML configuration files here: # Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended # Tasks: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended @@ -21,7 +26,7 @@ class PoemCrew: @agent def poem_writer(self) -> Agent: return Agent( - config=self.agents_config["poem_writer"], + config=self.agents_config["poem_writer"], # type: ignore[index] ) # To learn more about structured task outputs, @@ -30,7 +35,7 @@ class PoemCrew: @task def write_poem(self) -> Task: return Task( - config=self.tasks_config["write_poem"], + config=self.tasks_config["write_poem"], # type: ignore[index] ) @crew diff --git a/src/crewai/cli/utils.py b/src/crewai/cli/utils.py index 8912036db..078afec60 100644 --- a/src/crewai/cli/utils.py +++ b/src/crewai/cli/utils.py @@ -273,11 +273,9 @@ def get_crew(crew_path: str = "crew.py", require: bool = False) -> Crew | None: for attr_name in dir(module): attr = getattr(module, attr_name) try: - if isinstance(attr, Crew) and hasattr(attr, "kickoff"): - print( - f"Found valid crew object in attribute '{attr_name}' at {crew_os_path}." - ) - return attr + if callable(attr) and hasattr(attr, "crew"): + crew_instance = attr().crew() + return crew_instance except Exception as e: print(f"Error processing attribute {attr_name}: {e}") diff --git a/src/crewai/crew.py b/src/crewai/crew.py index 6fab2cec5..f1c33f637 100644 --- a/src/crewai/crew.py +++ b/src/crewai/crew.py @@ -275,46 +275,51 @@ class Crew(BaseModel): return self + def _initialize_user_memory(self): + if ( + self.memory_config + and "user_memory" in self.memory_config + and self.memory_config.get("provider") == "mem0" + ): # Check for user_memory in config + user_memory_config = self.memory_config["user_memory"] + if isinstance( + user_memory_config, dict + ): # Check if it's a configuration dict + self._user_memory = UserMemory(crew=self) + else: + raise TypeError("user_memory must be a configuration dictionary") + + def _initialize_default_memories(self): + self._long_term_memory = self._long_term_memory or LongTermMemory() + self._short_term_memory = self._short_term_memory or ShortTermMemory( + crew=self, + embedder_config=self.embedder, + ) + self._entity_memory = self.entity_memory or EntityMemory( + crew=self, embedder_config=self.embedder + ) + @model_validator(mode="after") def create_crew_memory(self) -> "Crew": - """Set private attributes.""" + """Initialize private memory attributes.""" + self._external_memory = ( + # External memory doesn’t support a default value since it was designed to be managed entirely externally + self.external_memory.set_crew(self) + if self.external_memory + else None + ) + + self._long_term_memory = self.long_term_memory + self._short_term_memory = self.short_term_memory + self._entity_memory = self.entity_memory + + # UserMemory is gonna to be deprecated in the future, but we have to initialize a default value for now + self._user_memory = None + if self.memory: - self._long_term_memory = ( - self.long_term_memory if self.long_term_memory else LongTermMemory() - ) - self._short_term_memory = ( - self.short_term_memory - if self.short_term_memory - else ShortTermMemory( - crew=self, - embedder_config=self.embedder, - ) - ) - self._entity_memory = ( - self.entity_memory - if self.entity_memory - else EntityMemory(crew=self, embedder_config=self.embedder) - ) - self._external_memory = ( - # External memory doesn’t support a default value since it was designed to be managed entirely externally - self.external_memory.set_crew(self) - if self.external_memory - else None - ) - if ( - self.memory_config - and "user_memory" in self.memory_config - and self.memory_config.get("provider") == "mem0" - ): # Check for user_memory in config - user_memory_config = self.memory_config["user_memory"] - if isinstance( - user_memory_config, dict - ): # Check if it's a configuration dict - self._user_memory = UserMemory(crew=self) - else: - raise TypeError("user_memory must be a configuration dictionary") - else: - self._user_memory = None # No user memory if not in config + self._initialize_default_memories() + self._initialize_user_memory() + return self @model_validator(mode="after") @@ -1214,6 +1219,17 @@ class Crew(BaseModel): copied_data = self.model_dump(exclude=exclude) copied_data = {k: v for k, v in copied_data.items() if v is not None} + if self.short_term_memory: + copied_data["short_term_memory"] = self.short_term_memory.model_copy(deep=True) + if self.long_term_memory: + copied_data["long_term_memory"] = self.long_term_memory.model_copy(deep=True) + if self.entity_memory: + copied_data["entity_memory"] = self.entity_memory.model_copy(deep=True) + if self.external_memory: + copied_data["external_memory"] = self.external_memory.model_copy(deep=True) + if self.user_memory: + copied_data["user_memory"] = self.user_memory.model_copy(deep=True) + copied_data.pop("agents", None) copied_data.pop("tasks", None) @@ -1383,12 +1399,12 @@ class Crew(BaseModel): RuntimeError: If the specified memory system fails to reset """ reset_functions = { - "long": (self._long_term_memory, "long term"), - "short": (self._short_term_memory, "short term"), - "entity": (self._entity_memory, "entity"), - "knowledge": (self.knowledge, "knowledge"), - "kickoff_outputs": (self._task_output_handler, "task output"), - "external": (self._external_memory, "external"), + "long": (getattr(self, "_long_term_memory", None), "long term"), + "short": (getattr(self, "_short_term_memory", None), "short term"), + "entity": (getattr(self, "_entity_memory", None), "entity"), + "knowledge": (getattr(self, "knowledge", None), "knowledge"), + "kickoff_outputs": (getattr(self, "_task_output_handler", None), "task output"), + "external": (getattr(self, "_external_memory", None), "external"), } memory_system, name = reset_functions[memory_type] diff --git a/src/crewai/flow/persistence/sqlite.py b/src/crewai/flow/persistence/sqlite.py index 21e906afd..8b2a0f3f2 100644 --- a/src/crewai/flow/persistence/sqlite.py +++ b/src/crewai/flow/persistence/sqlite.py @@ -21,7 +21,7 @@ class SQLiteFlowPersistence(FlowPersistence): moderate performance requirements. """ - db_path: str # Type annotation for instance variable + db_path: str def __init__(self, db_path: Optional[str] = None): """Initialize SQLite persistence. diff --git a/src/crewai/llm.py b/src/crewai/llm.py index 25b798a6d..332582744 100644 --- a/src/crewai/llm.py +++ b/src/crewai/llm.py @@ -4,9 +4,12 @@ import os import sys import threading import warnings +from collections import defaultdict from contextlib import contextmanager +from types import SimpleNamespace from typing import ( Any, + DefaultDict, Dict, List, Literal, @@ -18,7 +21,8 @@ from typing import ( ) from dotenv import load_dotenv -from pydantic import BaseModel +from litellm.types.utils import ChatCompletionDeltaToolCall +from pydantic import BaseModel, Field from crewai.utilities.events.llm_events import ( LLMCallCompletedEvent, @@ -219,6 +223,15 @@ class StreamingChoices(TypedDict): finish_reason: Optional[str] +class FunctionArgs(BaseModel): + name: str = "" + arguments: str = "" + + +class AccumulatedToolArgs(BaseModel): + function: FunctionArgs = Field(default_factory=FunctionArgs) + + class LLM(BaseLLM): def __init__( self, @@ -371,6 +384,11 @@ class LLM(BaseLLM): last_chunk = None chunk_count = 0 usage_info = None + tool_calls = None + + accumulated_tool_args: DefaultDict[int, AccumulatedToolArgs] = defaultdict( + AccumulatedToolArgs + ) # --- 2) Make sure stream is set to True and include usage metrics params["stream"] = True @@ -428,6 +446,20 @@ class LLM(BaseLLM): if chunk_content is None and isinstance(delta, dict): # Some models might send empty content chunks chunk_content = "" + + # Enable tool calls using streaming + if "tool_calls" in delta: + tool_calls = delta["tool_calls"] + + if tool_calls: + result = self._handle_streaming_tool_calls( + tool_calls=tool_calls, + accumulated_tool_args=accumulated_tool_args, + available_functions=available_functions, + ) + if result is not None: + chunk_content = result + except Exception as e: logging.debug(f"Error extracting content from chunk: {e}") logging.debug(f"Chunk format: {type(chunk)}, content: {chunk}") @@ -442,7 +474,6 @@ class LLM(BaseLLM): self, event=LLMStreamChunkEvent(chunk=chunk_content), ) - # --- 4) Fallback to non-streaming if no content received if not full_response.strip() and chunk_count == 0: logging.warning( @@ -501,7 +532,7 @@ class LLM(BaseLLM): ) # --- 6) If still empty, raise an error instead of using a default response - if not full_response.strip(): + if not full_response.strip() and len(accumulated_tool_args) == 0: raise Exception( "No content received from streaming response. Received empty chunks or failed to extract content." ) @@ -533,8 +564,8 @@ class LLM(BaseLLM): tool_calls = getattr(message, "tool_calls") except Exception as e: logging.debug(f"Error checking for tool calls: {e}") - # --- 8) If no tool calls or no available functions, return the text response directly + if not tool_calls or not available_functions: # Log token usage if available in streaming mode self._handle_streaming_callbacks(callbacks, usage_info, last_chunk) @@ -568,6 +599,47 @@ class LLM(BaseLLM): ) raise Exception(f"Failed to get streaming response: {str(e)}") + def _handle_streaming_tool_calls( + self, + tool_calls: List[ChatCompletionDeltaToolCall], + accumulated_tool_args: DefaultDict[int, AccumulatedToolArgs], + available_functions: Optional[Dict[str, Any]] = None, + ) -> None | str: + for tool_call in tool_calls: + current_tool_accumulator = accumulated_tool_args[tool_call.index] + + if tool_call.function.name: + current_tool_accumulator.function.name = tool_call.function.name + + if tool_call.function.arguments: + current_tool_accumulator.function.arguments += ( + tool_call.function.arguments + ) + + crewai_event_bus.emit( + self, + event=LLMStreamChunkEvent( + tool_call=tool_call.to_dict(), + chunk=tool_call.function.arguments, + ), + ) + + if ( + current_tool_accumulator.function.name + and current_tool_accumulator.function.arguments + and available_functions + ): + try: + json.loads(current_tool_accumulator.function.arguments) + + return self._handle_tool_call( + [current_tool_accumulator], + available_functions, + ) + except json.JSONDecodeError: + continue + return None + def _handle_streaming_callbacks( self, callbacks: Optional[List[Any]], diff --git a/src/crewai/memory/contextual/contextual_memory.py b/src/crewai/memory/contextual/contextual_memory.py index 23e79986f..c88614800 100644 --- a/src/crewai/memory/contextual/contextual_memory.py +++ b/src/crewai/memory/contextual/contextual_memory.py @@ -53,6 +53,10 @@ class ContextualMemory: Fetches recent relevant insights from STM related to the task's description and expected_output, formatted as bullet points. """ + + if self.stm is None: + return "" + stm_results = self.stm.search(query) formatted_results = "\n".join( [ @@ -67,6 +71,10 @@ class ContextualMemory: Fetches historical data or insights from LTM that are relevant to the task's description and expected_output, formatted as bullet points. """ + + if self.ltm is None: + return "" + ltm_results = self.ltm.search(task, latest_n=2) if not ltm_results: return None @@ -86,6 +94,9 @@ class ContextualMemory: Fetches relevant entity information from Entity Memory related to the task's description and expected_output, formatted as bullet points. """ + if self.em is None: + return "" + em_results = self.em.search(query) formatted_results = "\n".join( [ diff --git a/src/crewai/memory/storage/mem0_storage.py b/src/crewai/memory/storage/mem0_storage.py index ccf8cc810..835788727 100644 --- a/src/crewai/memory/storage/mem0_storage.py +++ b/src/crewai/memory/storage/mem0_storage.py @@ -48,7 +48,7 @@ class Mem0Storage(Storage): self.memory = MemoryClient(api_key=mem0_api_key) else: if mem0_local_config and len(mem0_local_config): - self.memory = Memory.from_config(config) + self.memory = Memory.from_config(mem0_local_config) else: self.memory = Memory() diff --git a/src/crewai/telemetry/constants.py b/src/crewai/telemetry/constants.py new file mode 100644 index 000000000..95820a774 --- /dev/null +++ b/src/crewai/telemetry/constants.py @@ -0,0 +1,2 @@ +CREWAI_TELEMETRY_BASE_URL: str = "https://telemetry.crewai.com:4319" +CREWAI_TELEMETRY_SERVICE_NAME: str = "crewAI-telemetry" diff --git a/src/crewai/telemetry/telemetry.py b/src/crewai/telemetry/telemetry.py index 6fec368b3..6821d5e22 100644 --- a/src/crewai/telemetry/telemetry.py +++ b/src/crewai/telemetry/telemetry.py @@ -9,6 +9,11 @@ from contextlib import contextmanager from importlib.metadata import version from typing import TYPE_CHECKING, Any, Optional +from crewai.telemetry.constants import ( + CREWAI_TELEMETRY_BASE_URL, + CREWAI_TELEMETRY_SERVICE_NAME, +) + @contextmanager def suppress_warnings(): @@ -52,16 +57,15 @@ class Telemetry: return try: - telemetry_endpoint = "https://telemetry.crewai.com:4319" self.resource = Resource( - attributes={SERVICE_NAME: "crewAI-telemetry"}, + attributes={SERVICE_NAME: CREWAI_TELEMETRY_SERVICE_NAME}, ) with suppress_warnings(): self.provider = TracerProvider(resource=self.resource) processor = BatchSpanProcessor( OTLPSpanExporter( - endpoint=f"{telemetry_endpoint}/v1/traces", + endpoint=f"{CREWAI_TELEMETRY_BASE_URL}/v1/traces", timeout=30, ) ) @@ -75,12 +79,12 @@ class Telemetry: ): raise # Re-raise the exception to not interfere with system signals self.ready = False - + def _is_telemetry_disabled(self) -> bool: """Check if telemetry should be disabled based on environment variables.""" return ( - os.getenv("OTEL_SDK_DISABLED", "false").lower() == "true" or - os.getenv("CREWAI_DISABLE_TELEMETRY", "false").lower() == "true" + os.getenv("OTEL_SDK_DISABLED", "false").lower() == "true" + or os.getenv("CREWAI_DISABLE_TELEMETRY", "false").lower() == "true" ) def set_tracer(self): diff --git a/src/crewai/utilities/converter.py b/src/crewai/utilities/converter.py index b16677ace..a6144868e 100644 --- a/src/crewai/utilities/converter.py +++ b/src/crewai/utilities/converter.py @@ -216,7 +216,7 @@ def convert_with_instructions( def get_conversion_instructions(model: Type[BaseModel], llm: Any) -> str: instructions = "Please convert the following text into valid JSON." - if llm.supports_function_calling(): + if llm and not isinstance(llm, str) and llm.supports_function_calling(): model_schema = PydanticSchemaParser(model=model).get_schema() instructions += ( f"\n\nOutput ONLY the valid JSON and nothing else.\n\n" diff --git a/src/crewai/utilities/events/llm_events.py b/src/crewai/utilities/events/llm_events.py index 07a17a48b..ca8d0367a 100644 --- a/src/crewai/utilities/events/llm_events.py +++ b/src/crewai/utilities/events/llm_events.py @@ -1,6 +1,8 @@ from enum import Enum from typing import Any, Dict, List, Optional, Union +from pydantic import BaseModel + from crewai.utilities.events.base_events import BaseEvent @@ -41,8 +43,21 @@ class LLMCallFailedEvent(BaseEvent): type: str = "llm_call_failed" +class FunctionCall(BaseModel): + arguments: str + name: Optional[str] = None + + +class ToolCall(BaseModel): + id: Optional[str] = None + function: FunctionCall + type: Optional[str] = None + index: int + + class LLMStreamChunkEvent(BaseEvent): """Event emitted when a streaming chunk is received""" type: str = "llm_stream_chunk" chunk: str + tool_call: Optional[ToolCall] = None diff --git a/tests/agents/agent_adapters/test_base_agent_adapter.py b/tests/agents/agent_adapters/test_base_agent_adapter.py new file mode 100644 index 000000000..2da90b719 --- /dev/null +++ b/tests/agents/agent_adapters/test_base_agent_adapter.py @@ -0,0 +1,113 @@ +from typing import Any, Dict, List, Optional + +import pytest +from pydantic import BaseModel + +from crewai.agent import BaseAgent +from crewai.agents.agent_adapters.base_agent_adapter import BaseAgentAdapter +from crewai.tools import BaseTool +from crewai.utilities.token_counter_callback import TokenProcess + + +# Concrete implementation for testing +class ConcreteAgentAdapter(BaseAgentAdapter): + def configure_tools( + self, tools: Optional[List[BaseTool]] = None, **kwargs: Any + ) -> None: + # Simple implementation for testing + self.tools = tools or [] + + def execute_task( + self, + task: Any, + context: Optional[str] = None, + tools: Optional[List[Any]] = None, + ) -> str: + # Dummy implementation needed due to BaseAgent inheritance + return "Task executed" + + def create_agent_executor(self, tools: Optional[List[BaseTool]] = None) -> Any: + # Dummy implementation + return None + + def get_delegation_tools( + self, tools: List[BaseTool], tool_map: Optional[Dict[str, BaseTool]] + ) -> List[BaseTool]: + # Dummy implementation + return [] + + def _parse_output(self, agent_output: Any, token_process: TokenProcess): + # Dummy implementation + pass + + def get_output_converter(self, tools: Optional[List[BaseTool]] = None) -> Any: + # Dummy implementation + return None + + +def test_base_agent_adapter_initialization(): + """Test initialization of the concrete agent adapter.""" + adapter = ConcreteAgentAdapter( + role="test role", goal="test goal", backstory="test backstory" + ) + assert isinstance(adapter, BaseAgent) + assert isinstance(adapter, BaseAgentAdapter) + assert adapter.role == "test role" + assert adapter._agent_config is None + assert adapter.adapted_structured_output is False + + +def test_base_agent_adapter_initialization_with_config(): + """Test initialization with agent_config.""" + config = {"model": "gpt-4"} + adapter = ConcreteAgentAdapter( + agent_config=config, + role="test role", + goal="test goal", + backstory="test backstory", + ) + assert adapter._agent_config == config + + +def test_configure_tools_method_exists(): + """Test that configure_tools method exists and can be called.""" + adapter = ConcreteAgentAdapter( + role="test role", goal="test goal", backstory="test backstory" + ) + # Create dummy tools if needed, or pass None + tools = [] + adapter.configure_tools(tools) + assert hasattr(adapter, "tools") + assert adapter.tools == tools + + +def test_configure_structured_output_method_exists(): + """Test that configure_structured_output method exists and can be called.""" + adapter = ConcreteAgentAdapter( + role="test role", goal="test goal", backstory="test backstory" + ) + + # Define a dummy structure or pass None/Any + class DummyOutput(BaseModel): + data: str + + structured_output = DummyOutput + adapter.configure_structured_output(structured_output) + # Add assertions here if configure_structured_output modifies state + # For now, just ensuring it runs without error is sufficient + pass + + +def test_base_agent_adapter_inherits_base_agent(): + """Test that BaseAgentAdapter inherits from BaseAgent.""" + assert issubclass(BaseAgentAdapter, BaseAgent) + + +class ConcreteAgentAdapterWithoutRequiredMethods(BaseAgentAdapter): + pass + + +def test_base_agent_adapter_fails_without_required_methods(): + """Test that BaseAgentAdapter fails without required methods.""" + with pytest.raises(TypeError): + ConcreteAgentAdapterWithoutRequiredMethods() # type: ignore diff --git a/tests/agents/agent_adapters/test_base_tool_adapter.py b/tests/agents/agent_adapters/test_base_tool_adapter.py new file mode 100644 index 000000000..3003d92c3 --- /dev/null +++ b/tests/agents/agent_adapters/test_base_tool_adapter.py @@ -0,0 +1,94 @@ +from typing import Any, List +from unittest.mock import Mock + +import pytest + +from crewai.agents.agent_adapters.base_tool_adapter import BaseToolAdapter +from crewai.tools.base_tool import BaseTool + + +class ConcreteToolAdapter(BaseToolAdapter): + def configure_tools(self, tools: List[BaseTool]) -> None: + self.converted_tools = [f"converted_{tool.name}" for tool in tools] + + +@pytest.fixture +def mock_tool_1(): + tool = Mock(spec=BaseTool) + tool.name = "Mock Tool 1" + return tool + + +@pytest.fixture +def mock_tool_2(): + tool = Mock(spec=BaseTool) + tool.name = "MockTool2" + return tool + + +@pytest.fixture +def tools_list(mock_tool_1, mock_tool_2): + return [mock_tool_1, mock_tool_2] + + +def test_initialization_with_tools(tools_list): + adapter = ConcreteToolAdapter(tools=tools_list) + assert adapter.original_tools == tools_list + assert adapter.converted_tools == [] # Conversion happens in configure_tools + + +def test_initialization_without_tools(): + adapter = ConcreteToolAdapter() + assert adapter.original_tools == [] + assert adapter.converted_tools == [] + + +def test_configure_tools(tools_list): + adapter = ConcreteToolAdapter() + adapter.configure_tools(tools_list) + assert adapter.converted_tools == ["converted_Mock Tool 1", "converted_MockTool2"] + assert adapter.original_tools == [] # original_tools is only set in init + + adapter_with_init_tools = ConcreteToolAdapter(tools=tools_list) + adapter_with_init_tools.configure_tools(tools_list) + assert adapter_with_init_tools.converted_tools == [ + "converted_Mock Tool 1", + "converted_MockTool2", + ] + assert adapter_with_init_tools.original_tools == tools_list + + +def test_tools_method(tools_list): + adapter = ConcreteToolAdapter() + adapter.configure_tools(tools_list) + assert adapter.tools() == ["converted_Mock Tool 1", "converted_MockTool2"] + + +def test_tools_method_empty(): + adapter = ConcreteToolAdapter() + assert adapter.tools() == [] + + +def test_sanitize_tool_name_with_spaces(): + adapter = ConcreteToolAdapter() + assert adapter.sanitize_tool_name("Tool With Spaces") == "Tool_With_Spaces" + + +def test_sanitize_tool_name_without_spaces(): + adapter = ConcreteToolAdapter() + assert adapter.sanitize_tool_name("ToolWithoutSpaces") == "ToolWithoutSpaces" + + +def test_sanitize_tool_name_empty(): + adapter = ConcreteToolAdapter() + assert adapter.sanitize_tool_name("") == "" + + +class ConcreteToolAdapterWithoutRequiredMethods(BaseToolAdapter): + pass + + +def test_tool_adapted_fails_without_required_methods(): + """Test that BaseToolAdapter fails without required methods.""" + with pytest.raises(TypeError): + ConcreteToolAdapterWithoutRequiredMethods() # type: ignore diff --git a/tests/agents/agent_builder/base_agent_test.py b/tests/agents/agent_builder/base_agent_test.py index 99f66dcc4..59faa6ba3 100644 --- a/tests/agents/agent_builder/base_agent_test.py +++ b/tests/agents/agent_builder/base_agent_test.py @@ -18,9 +18,6 @@ class MockAgent(BaseAgent): def create_agent_executor(self, tools=None) -> None: ... - def _parse_tools(self, tools: List[BaseTool]) -> List[BaseTool]: - return [] - def get_delegation_tools(self, agents: List["BaseAgent"]): ... def get_output_converter( diff --git a/tests/memory/external/cassettes/test_crew_external_memory_save.yaml b/tests/cassettes/test_crew_external_memory_save.yaml similarity index 100% rename from tests/memory/external/cassettes/test_crew_external_memory_save.yaml rename to tests/cassettes/test_crew_external_memory_save.yaml diff --git a/tests/cassettes/test_crew_external_memory_save_using_crew_without_memory_flag[save].yaml b/tests/cassettes/test_crew_external_memory_save_using_crew_without_memory_flag[save].yaml new file mode 100644 index 000000000..eb4f7834a --- /dev/null +++ b/tests/cassettes/test_crew_external_memory_save_using_crew_without_memory_flag[save].yaml @@ -0,0 +1,182 @@ +interactions: +- request: + body: !!binary | + Ct8MCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkStgwKEgoQY3Jld2FpLnRl + bGVtZXRyeRKcCAoQfm0pqVSMD2d8x7Z0oecKIRIIgWppMg8y3GoqDENyZXcgQ3JlYXRlZDABORAN + KtAWrDUYQagXMtAWrDUYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGgoOcHl0aG9uX3Zl + cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIDA3YTcxNzY4Y2M0YzkzZWFiM2IzMWUzYzhk + MjgzMmM2SjEKB2NyZXdfaWQSJgokNGY1NjNkN2MtYmYyOC00ZWM2LTgzNzQtMDZlMjZiYzA1NWU0 + ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3 + X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3 + X2ZpbmdlcnByaW50EiYKJGU4MGY4MDFmLWViZmQtNDlkOS1iNTEwLTM0NmVjN2VlNzAzZko7Chtj + cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xMlQxNzoyNzoyNC42NTU4NzhK + 0AIKC2NyZXdfYWdlbnRzEsACCr0CW3sia2V5IjogIjAyZGYxM2UzNjcxMmFiZjUxZDIzOGZlZWJh + YjFjYTI2IiwgImlkIjogIjg5MjdlNzQ1LWNkNWQtNDJkMy1hMjA2LTEyYTUxOWRlMDY1OCIsICJy + b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiB0cnVlLCAibWF4X2l0ZXIiOiAyNSwgIm1h + eF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8t + bWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlv + bj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtdfV1K/wEK + CmNyZXdfdGFza3MS8AEK7QFbeyJrZXkiOiAiN2I0MmRmM2MzYzc0YzIxYzg5NDgwZTBjMDcwNTM4 + NWYiLCAiaWQiOiAiNDM0MDgzNDYtMjA5OC00M2I1LWE0NWUtMmU2MWY4ZmYxZTliIiwgImFzeW5j + X2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6 + ICJSZXNlYXJjaGVyIiwgImFnZW50X2tleSI6ICIwMmRmMTNlMzY3MTJhYmY1MWQyMzhmZWViYWIx + Y2EyNiIsICJ0b29sc19uYW1lcyI6IFtdfV16AhgBhQEAAQAAEoAEChDv1iM8ejIY7tezTF4KBssA + Eghn2bJnw2f60SoMVGFzayBDcmVhdGVkMAE58LFA0BasNRhB4AdB0BasNRhKLgoIY3Jld19rZXkS + IgogMDdhNzE3NjhjYzRjOTNlYWIzYjMxZTNjOGQyODMyYzZKMQoHY3Jld19pZBImCiQ0ZjU2M2Q3 + Yy1iZjI4LTRlYzYtODM3NC0wNmUyNmJjMDU1ZTRKLgoIdGFza19rZXkSIgogN2I0MmRmM2MzYzc0 + YzIxYzg5NDgwZTBjMDcwNTM4NWZKMQoHdGFza19pZBImCiQ0MzQwODM0Ni0yMDk4LTQzYjUtYTQ1 + ZS0yZTYxZjhmZjFlOWJKOgoQY3Jld19maW5nZXJwcmludBImCiRlODBmODAxZi1lYmZkLTQ5ZDkt + YjUxMC0zNDZlYzdlZTcwM2ZKOgoQdGFza19maW5nZXJwcmludBImCiQ2YjgzODVkYS0yYWJjLTRm + NWEtOTk3NC0xNjhiMzVhNDBlOTlKOwobdGFza19maW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIw + MjUtMDQtMTJUMTc6Mjc6MjQuNjU1ODQ4SjsKEWFnZW50X2ZpbmdlcnByaW50EiYKJDIyNTI4NDRl + LWNlMTYtNDYyZi04NDI4LTYwYzZmMWYyNGE3N3oCGAGFAQABAAA= + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '1634' + Content-Type: + - application/x-protobuf + User-Agent: + - OTel-OTLP-Exporter-Python/1.31.1 + 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: + - Sat, 12 Apr 2025 20:27:26 GMT + status: + code: 200 + message: OK +- request: + body: '{"messages": [{"role": "system", "content": "You are Researcher. You are + a researcher at a leading tech think tank.\nYour personal goal is: Search relevant + data and provide results\nTo give my best complete final answer to the task + respond using 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 complete + as possible, it must be outcome described.\n\nI MUST use these formats, my job + depends on it!"}, {"role": "user", "content": "\nCurrent Task: Perform a search + on specific topics.\n\nThis is the expected criteria for your final answer: + A list of relevant URLs based on the search query.\nyou MUST return the actual + complete content as the final answer, not a summary.\n\n# Useful context: \nExternal + memories:\n\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:"}], "model": + "gpt-4o-mini", "stop": ["\nObservation:"]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '989' + content-type: + - application/json + cookie: + - __cf_bm=nSje5Zn_Lk69BDG85XIauC2hrZjGl0pR2sel9__KWGw-1744489610-1.0.1.1-CPlAgcgTAE30uWrbi_2wiCWrbRDRWiaa.YuQMgST42DLDVg_wdNlJMDQT3Lsqk.g.BO68A66TTirWA0blQaQw.9xdBbPwKO609_ftjdwi5U; + _cfuvid=XLC52GLAWCOeWn2vI379CnSGKjPa7f.qr2vSAQ_R66M-1744489610542-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BLbjg0OfADWdrLsZxrjKHEeVVbWle\",\n \"object\": + \"chat.completion\",\n \"created\": 1744489644,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": \"I now can give a great answer \\nFinal + Answer: Here is a list of relevant URLs based on the specified search query: + \ \\n\\n1. https://www.forbes.com/technology/ \\n2. https://www.sciencedirect.com/ + \ \\n3. https://www.techcrunch.com/ \\n4. https://www.wired.com/ \\n5. https://www.researchgate.net/ + \ \\n6. https://www.springer.com/ \\n7. https://www.jstor.org/ \\n8. https://www.statista.com/ + \ \\n9. https://www.pwc.com/gx/en/services/consulting/technology.html \\n10. + https://www.gartner.com/en/information-technology \\n\\nThese URLs provide + access to a wealth of information on various technology-related topics, including + articles, research papers, and analytics.\",\n \"refusal\": null,\n \"annotations\": + []\n },\n \"logprobs\": null,\n \"finish_reason\": \"stop\"\n + \ }\n ],\n \"usage\": {\n \"prompt_tokens\": 185,\n \"completion_tokens\": + 169,\n \"total_tokens\": 354,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_80cf447eee\"\n}\n" + headers: + CF-RAY: + - 92f576d83a447e05-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:27 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '2273' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999788' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_38f6879956c29e6c61c844d1906fa2e8 + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/cassettes/test_crew_external_memory_save_using_crew_without_memory_flag[search].yaml b/tests/cassettes/test_crew_external_memory_save_using_crew_without_memory_flag[search].yaml new file mode 100644 index 000000000..d29762490 --- /dev/null +++ b/tests/cassettes/test_crew_external_memory_save_using_crew_without_memory_flag[search].yaml @@ -0,0 +1,190 @@ +interactions: +- request: + body: !!binary | + Ct8MCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkStgwKEgoQY3Jld2FpLnRl + bGVtZXRyeRKcCAoQjin/Su47zAwLq3Hv6yv8GhIImRMfAPs+FOMqDENyZXcgQ3JlYXRlZDABOYCY + xbgUrDUYQVie07gUrDUYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGgoOcHl0aG9uX3Zl + cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIDA3YTcxNzY4Y2M0YzkzZWFiM2IzMWUzYzhk + MjgzMmM2SjEKB2NyZXdfaWQSJgokY2UyMGFlNWYtZmMyNy00YWJhLWExYWMtNzUwY2ZhZmMwMTE4 + ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3 + X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3 + X2ZpbmdlcnByaW50EiYKJDQ4NGFmZDhjLTczMmEtNGM1Ni1hZjk2LTU2MzkwMjNmYjhjOUo7Chtj + cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xMlQxNzoyNzoxNS42NzMyMjNK + 0AIKC2NyZXdfYWdlbnRzEsACCr0CW3sia2V5IjogIjAyZGYxM2UzNjcxMmFiZjUxZDIzOGZlZWJh + YjFjYTI2IiwgImlkIjogImYyYjZkYTU1LTNiMGItNDZiNy05Mzk5LWE5NDJmYjQ4YzU2OSIsICJy + b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiB0cnVlLCAibWF4X2l0ZXIiOiAyNSwgIm1h + eF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8t + bWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlv + bj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtdfV1K/wEK + CmNyZXdfdGFza3MS8AEK7QFbeyJrZXkiOiAiN2I0MmRmM2MzYzc0YzIxYzg5NDgwZTBjMDcwNTM4 + NWYiLCAiaWQiOiAiYmE1MjFjNDgtYzcwNS00MDRlLWE5MDktMjkwZGM0NTlkOThkIiwgImFzeW5j + X2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6 + ICJSZXNlYXJjaGVyIiwgImFnZW50X2tleSI6ICIwMmRmMTNlMzY3MTJhYmY1MWQyMzhmZWViYWIx + Y2EyNiIsICJ0b29sc19uYW1lcyI6IFtdfV16AhgBhQEAAQAAEoAEChAmCOpHN6fX3l0shQvTLjrB + EgjLTyt4A1p7wyoMVGFzayBDcmVhdGVkMAE5gN7juBSsNRhBmFfkuBSsNRhKLgoIY3Jld19rZXkS + IgogMDdhNzE3NjhjYzRjOTNlYWIzYjMxZTNjOGQyODMyYzZKMQoHY3Jld19pZBImCiRjZTIwYWU1 + Zi1mYzI3LTRhYmEtYTFhYy03NTBjZmFmYzAxMThKLgoIdGFza19rZXkSIgogN2I0MmRmM2MzYzc0 + YzIxYzg5NDgwZTBjMDcwNTM4NWZKMQoHdGFza19pZBImCiRiYTUyMWM0OC1jNzA1LTQwNGUtYTkw + OS0yOTBkYzQ1OWQ5OGRKOgoQY3Jld19maW5nZXJwcmludBImCiQ0ODRhZmQ4Yy03MzJhLTRjNTYt + YWY5Ni01NjM5MDIzZmI4YzlKOgoQdGFza19maW5nZXJwcmludBImCiRhMDcyNjgwNC05ZjIwLTQw + ODgtYWFmOC1iNzhkYTUyNmM3NjlKOwobdGFza19maW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIw + MjUtMDQtMTJUMTc6Mjc6MTUuNjczMTgxSjsKEWFnZW50X2ZpbmdlcnByaW50EiYKJDNiZDE2MmNm + LWNmMWQtNGUwZi04ZmIzLTk3MDljMDkyNmM4ZHoCGAGFAQABAAA= + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '1634' + Content-Type: + - application/x-protobuf + User-Agent: + - OTel-OTLP-Exporter-Python/1.31.1 + 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: + - Sat, 12 Apr 2025 20:27:16 GMT + status: + code: 200 + message: OK +- request: + body: '{"messages": [{"role": "system", "content": "You are Researcher. You are + a researcher at a leading tech think tank.\nYour personal goal is: Search relevant + data and provide results\nTo give my best complete final answer to the task + respond using 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 complete + as possible, it must be outcome described.\n\nI MUST use these formats, my job + depends on it!"}, {"role": "user", "content": "\nCurrent Task: Perform a search + on specific topics.\n\nThis is the expected criteria for your final answer: + A list of relevant URLs based on the search query.\nyou MUST return the actual + complete content as the final answer, not a summary.\n\n# Useful context: \nExternal + memories:\n\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:"}], "model": + "gpt-4o-mini", "stop": ["\nObservation:"]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '989' + content-type: + - application/json + cookie: + - __cf_bm=nSje5Zn_Lk69BDG85XIauC2hrZjGl0pR2sel9__KWGw-1744489610-1.0.1.1-CPlAgcgTAE30uWrbi_2wiCWrbRDRWiaa.YuQMgST42DLDVg_wdNlJMDQT3Lsqk.g.BO68A66TTirWA0blQaQw.9xdBbPwKO609_ftjdwi5U; + _cfuvid=XLC52GLAWCOeWn2vI379CnSGKjPa7f.qr2vSAQ_R66M-1744489610542-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BLbjXyMvmR8ctf0sqhp7F1ePskveM\",\n \"object\": + \"chat.completion\",\n \"created\": 1744489635,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": \"I now can give a great answer \\nFinal + Answer: Here is a list of relevant URLs based on the search query:\\n\\n1. **Artificial + Intelligence in Healthcare**\\n - https://www.healthit.gov/topic/scientific-initiatives/ai-healthcare\\n + \ - https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7317789/\\n - https://www.forbes.com/sites/bernardmarr/2021/10/18/the-top-5-ways-ai-is-being-used-in-healthcare/?sh=3edf5df51c9c\\n\\n2. + **Blockchain Technology in Supply Chain Management**\\n - https://www.ibm.com/blockchain/supply-chain\\n + \ - https://www.gartner.com/en/newsroom/press-releases/2021-06-23-gartner-says-three-use-cases-for-blockchain-in-supply-chain-are-scaling\\n + \ - https://www2.deloitte.com/us/en/insights/industry/retail-distribution/blockchain-in-supply-chain.html\\n\\n3. + **Renewable Energy Innovations**\\n - https://www.irena.org/publications/2020/Sep/Renewable-Power-Generation-Costs-in-2020\\n + \ - https://www.nrel.gov/docs/fy20osti/77021.pdf\\n - https://www.cnbc.com/2021/11/03/renewable-energy-could-get-its-first-taste-of-markets-in-2021.html\\n\\n4. + **7G Technology Developments**\\n - https://www.sciencedirect.com/science/article/pii/S1389128619308189\\n + \ - https://www.forbes.com/sites/bernardmarr/2021/11/01/what-is-7g-technology-a-beginners-guide-to-the-future-of-mobile-communications/?sh=51b8a7e1464a\\n + \ - https://www.ericsson.com/en/reports-and-research/reports/7g-networks-a-powerful-future-for-connected-society\\n\\n5. + **Impact of Quantum Computing on Cybersecurity**\\n - https://www.ibm.com/blogs/research/2021/09/quantum-computing-cybersecurity/\\n + \ - https://www.sciencedirect.com/science/article/pii/S0167739X21000072\\n + \ - https://www.techrepublic.com/article/how-quantum-computing-will-change-cybersecurity/\\n\\nThese + URLs should provide comprehensive information on the topics searched, providing + valuable insights and data for your research needs.\",\n \"refusal\": + null,\n \"annotations\": []\n },\n \"logprobs\": null,\n \"finish_reason\": + \"stop\"\n }\n ],\n \"usage\": {\n \"prompt_tokens\": 185,\n \"completion_tokens\": + 534,\n \"total_tokens\": 719,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_80cf447eee\"\n}\n" + headers: + CF-RAY: + - 92f576a01d3b7e05-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:24 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '8805' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999788' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_7c2d313d0b5997e903553a782b2afa25 + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/cassettes/test_crew_external_memory_save_with_memory_flag[save].yaml b/tests/cassettes/test_crew_external_memory_save_with_memory_flag[save].yaml new file mode 100644 index 000000000..18452af8d --- /dev/null +++ b/tests/cassettes/test_crew_external_memory_save_with_memory_flag[save].yaml @@ -0,0 +1,1177 @@ +interactions: +- request: + body: !!binary | + Ct8MCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkStgwKEgoQY3Jld2FpLnRl + bGVtZXRyeRKcCAoQtU/NfTqPr0fEyFkYdGASDRIIJxZPXn5/zNgqDENyZXcgQ3JlYXRlZDABOZhA + mEIRrDUYQVh0n0IRrDUYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGgoOcHl0aG9uX3Zl + cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIDA3YTcxNzY4Y2M0YzkzZWFiM2IzMWUzYzhk + MjgzMmM2SjEKB2NyZXdfaWQSJgokMzU4Yzg3ZTgtMWJjYi00ZTg5LWFkYjAtOWJkMzc5Njg4NzE0 + ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAUoaChRjcmV3 + X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3 + X2ZpbmdlcnByaW50EiYKJDZiZDg1YjMyLTYzOGYtNDA1MS1hOWM4LTVkZTkwZTM5MDExZEo7Chtj + cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xMlQxNzoyNzowMC43MzA0ODlK + 0AIKC2NyZXdfYWdlbnRzEsACCr0CW3sia2V5IjogIjAyZGYxM2UzNjcxMmFiZjUxZDIzOGZlZWJh + YjFjYTI2IiwgImlkIjogIjc3ZjFhYTg3LWQ3YTgtNDQ5MC1hZmNiLWI3NWJkMTEyZGNjMCIsICJy + b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiB0cnVlLCAibWF4X2l0ZXIiOiAyNSwgIm1h + eF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8t + bWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlv + bj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtdfV1K/wEK + CmNyZXdfdGFza3MS8AEK7QFbeyJrZXkiOiAiN2I0MmRmM2MzYzc0YzIxYzg5NDgwZTBjMDcwNTM4 + NWYiLCAiaWQiOiAiNDA1NGIxZmQtNzcwNi00MDZkLTgzMGQtNTVmOGEwMzVkNjFhIiwgImFzeW5j + X2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6 + ICJSZXNlYXJjaGVyIiwgImFnZW50X2tleSI6ICIwMmRmMTNlMzY3MTJhYmY1MWQyMzhmZWViYWIx + Y2EyNiIsICJ0b29sc19uYW1lcyI6IFtdfV16AhgBhQEAAQAAEoAEChDc7rG19OvDzdSRgCeA+JjF + Eggip1l3bNlJlSoMVGFzayBDcmVhdGVkMAE5kAWpQhGsNRhByE+pQhGsNRhKLgoIY3Jld19rZXkS + IgogMDdhNzE3NjhjYzRjOTNlYWIzYjMxZTNjOGQyODMyYzZKMQoHY3Jld19pZBImCiQzNThjODdl + OC0xYmNiLTRlODktYWRiMC05YmQzNzk2ODg3MTRKLgoIdGFza19rZXkSIgogN2I0MmRmM2MzYzc0 + YzIxYzg5NDgwZTBjMDcwNTM4NWZKMQoHdGFza19pZBImCiQ0MDU0YjFmZC03NzA2LTQwNmQtODMw + ZC01NWY4YTAzNWQ2MWFKOgoQY3Jld19maW5nZXJwcmludBImCiQ2YmQ4NWIzMi02MzhmLTQwNTEt + YTljOC01ZGU5MGUzOTAxMWRKOgoQdGFza19maW5nZXJwcmludBImCiRmNTAzZDkwNS01NTY2LTRh + MDctYjA4MS01ODgwMjgzMDIzMDFKOwobdGFza19maW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIw + MjUtMDQtMTJUMTc6Mjc6MDAuNzMwNDMzSjsKEWFnZW50X2ZpbmdlcnByaW50EiYKJDQ2MTRjNjcw + LTQ1N2EtNGM3MS1iOTJkLTQ4Y2RkZWE4ZjM2MXoCGAGFAQABAAA= + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '1634' + Content-Type: + - application/x-protobuf + User-Agent: + - OTel-OTLP-Exporter-Python/1.31.1 + 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: + - Sat, 12 Apr 2025 20:27:01 GMT + status: + code: 200 + message: OK +- request: + body: '{"input": ["Perform a search on specific topics."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '115' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 7,\n \"total_tokens\": 7\n }\n}\n" + headers: + CF-RAY: + - 92f576434eef7e15-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:01 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=yqrLjIHNgBZCBqm4kFDjM8e3XRTTG5LAcOFqN6iQdWs-1744489621-1.0.1.1-EhHLxGbx2BL14i7t9_E1nI1UznFiCHbi9J_Jnm9zJ0MCqwSe__tJYBFuwj1kuI7S_tZiQOaAxhxlLxsQzVlnCOC9ygeiQPbsLbhHXotQR_w; + path=/; expires=Sat, 12-Apr-25 20:57:01 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=1_xXx2oU8BVxKpVLotINYKq_pEw_9aiweh.PcQL4lQo-1744489621938-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '154' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-5b584f9dc9-5x989 + x-envoy-upstream-service-time: + - '70' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999991' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_ebd76e6b585b3b38a30f23231e150447 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Perform a search on specific topics."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '115' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 7,\n \"total_tokens\": 7\n }\n}\n" + headers: + CF-RAY: + - 92f576496fe27ded-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:02 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=cR3UB8mqarbHmGoKX4j_dGO4qF39Epoc9INuvxf_oYw-1744489622-1.0.1.1-4KvvhHXyjYp0xWmM8C4keAQYtI32ipHCW7aBSiQSz9Ef2uz1cF.gEHWXcsIwbU2JmaVvRKP2CmAISkzMWc0CfrwjHlah52qvvbqETbaM348; + path=/; expires=Sat, 12-Apr-25 20:57:02 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=ENTtDEni.J8Fwif2S5LczePrB2zgM0X0vYqXgEVD6.E-1744489622943-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '114' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-79686db8dc-gc8vf + x-envoy-upstream-service-time: + - '100' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999991' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_33c596d5ab95fda904d93dfbfe83e72d + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"messages": [{"role": "system", "content": "You are Researcher. You are + a researcher at a leading tech think tank.\nYour personal goal is: Search relevant + data and provide results\nTo give my best complete final answer to the task + respond using 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 complete + as possible, it must be outcome described.\n\nI MUST use these formats, my job + depends on it!"}, {"role": "user", "content": "\nCurrent Task: Perform a search + on specific topics.\n\nThis is the expected criteria for your final answer: + A list of relevant URLs based on the search query.\nyou MUST return the actual + complete content as the final answer, not a summary.\n\n# Useful context: \nExternal + memories:\n\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:"}], "model": + "gpt-4o-mini", "stop": ["\nObservation:"]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '989' + content-type: + - application/json + cookie: + - __cf_bm=nSje5Zn_Lk69BDG85XIauC2hrZjGl0pR2sel9__KWGw-1744489610-1.0.1.1-CPlAgcgTAE30uWrbi_2wiCWrbRDRWiaa.YuQMgST42DLDVg_wdNlJMDQT3Lsqk.g.BO68A66TTirWA0blQaQw.9xdBbPwKO609_ftjdwi5U; + _cfuvid=XLC52GLAWCOeWn2vI379CnSGKjPa7f.qr2vSAQ_R66M-1744489610542-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BLbjLpLxzCjAsG2aQif1lOIo3b0U3\",\n \"object\": + \"chat.completion\",\n \"created\": 1744489623,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": \"I now can give a great answer. \\n\\nFinal + Answer: Here are some relevant URLs based on your search query. Please visit + the following links for comprehensive information on the specified topics:\\n\\n1. + **Artificial Intelligence Ethics**\\n - https://www.aaai.org/Ethics/AIEthics.pdf\\n + \ - https://plato.stanford.edu/entries/ethics-ai/\\n\\n2. **Impact of 5G Technology**\\n + \ - https://www.itu.int/en/ITU-T/focusgroups/5g/Documents/FG-5G-DOC-1830.zip\\n + \ - https://www.gsma.com/5g/\\n\\n3. **Quantum Computing Developments**\\n + \ - https://www.ibm.com/quantum-computing/\\n - https://www.microsoft.com/en-us/quantum\\n\\n4. + **Cybersecurity Trends 2023**\\n - https://www.csoonline.com/article/3642552/cybersecurity-trends-2023.html\\n + \ - https://www.forbes.com/sites/bernardmarr/2023/01/03/top-5-cybersecurity-trends-in-2023/\\n\\n5. + **Sustainable Technology Innovations**\\n - https://www.weforum.org/agenda/2023/01/10-innovations-sustainability/\\n + \ - https://www.greenbiz.com/article/13-sustainable-tech-solutions-watch-2023\\n\\nFeel + free to explore these URLs for detailed content on each topic.\",\n \"refusal\": + null,\n \"annotations\": []\n },\n \"logprobs\": null,\n \"finish_reason\": + \"stop\"\n }\n ],\n \"usage\": {\n \"prompt_tokens\": 185,\n \"completion_tokens\": + 303,\n \"total_tokens\": 488,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_80cf447eee\"\n}\n" + headers: + CF-RAY: + - 92f5764fbaa57e05-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:07 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '3968' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999788' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_cba7a89b5f65cfa0a4aee19bc4378811 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["I now can give a great answer. Final Answer: Here are some + relevant URLs based on your search query. Please visit the following links for + comprehensive information on the specified topics: 1. **Artificial Intelligence + Ethics** - https://www.aaai.org/Ethics/AIEthics.pdf - https://plato.stanford.edu/entries/ethics-ai/ 2. + **Impact of 5G Technology** - https://www.itu.int/en/ITU-T/focusgroups/5g/Documents/FG-5G-DOC-1830.zip - + https://www.gsma.com/5g/ 3. **Quantum Computing Developments** - https://www.ibm.com/quantum-computing/ - + https://www.microsoft.com/en-us/quantum 4. **Cybersecurity Trends 2023** - + https://www.csoonline.com/article/3642552/cybersecurity-trends-2023.html - + https://www.forbes.com/sites/bernardmarr/2023/01/03/top-5-cybersecurity-trends-in-2023/ 5. + **Sustainable Technology Innovations** - https://www.weforum.org/agenda/2023/01/10-innovations-sustainability/ - + https://www.greenbiz.com/article/13-sustainable-tech-solutions-watch-2023 Feel + free to explore these URLs for detailed content on each topic."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '1144' + content-type: + - application/json + cookie: + - __cf_bm=yqrLjIHNgBZCBqm4kFDjM8e3XRTTG5LAcOFqN6iQdWs-1744489621-1.0.1.1-EhHLxGbx2BL14i7t9_E1nI1UznFiCHbi9J_Jnm9zJ0MCqwSe__tJYBFuwj1kuI7S_tZiQOaAxhxlLxsQzVlnCOC9ygeiQPbsLbhHXotQR_w; + _cfuvid=1_xXx2oU8BVxKpVLotINYKq_pEw_9aiweh.PcQL4lQo-1744489621938-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 312,\n \"total_tokens\": 312\n }\n}\n" + headers: + CF-RAY: + - 92f57669ba517df2-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:07 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '92' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-79686db8dc-7s4fn + x-envoy-upstream-service-time: + - '57' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999734' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 1ms + x-request-id: + - req_5a74344cf91970e2ce1bdf6021f4f127 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"messages": [{"role": "user", "content": "Assess the quality of the task + completed based on the description, expected output, and actual results.\n\nTask + Description:\nPerform a search on specific topics.\n\nExpected Output:\nA list + of relevant URLs based on the search query.\n\nActual Output:\nI now can give + a great answer. \n\nFinal Answer: Here are some relevant URLs based on your + search query. Please visit the following links for comprehensive information + on the specified topics:\n\n1. **Artificial Intelligence Ethics**\n - https://www.aaai.org/Ethics/AIEthics.pdf\n - + https://plato.stanford.edu/entries/ethics-ai/\n\n2. **Impact of 5G Technology**\n - + https://www.itu.int/en/ITU-T/focusgroups/5g/Documents/FG-5G-DOC-1830.zip\n - + https://www.gsma.com/5g/\n\n3. **Quantum Computing Developments**\n - https://www.ibm.com/quantum-computing/\n - + https://www.microsoft.com/en-us/quantum\n\n4. **Cybersecurity Trends 2023**\n - + https://www.csoonline.com/article/3642552/cybersecurity-trends-2023.html\n - + https://www.forbes.com/sites/bernardmarr/2023/01/03/top-5-cybersecurity-trends-in-2023/\n\n5. + **Sustainable Technology Innovations**\n - https://www.weforum.org/agenda/2023/01/10-innovations-sustainability/\n - + https://www.greenbiz.com/article/13-sustainable-tech-solutions-watch-2023\n\nFeel + free to explore these URLs for detailed content on each topic.\n\nPlease provide:\n- + Bullet points suggestions to improve future similar tasks\n- A score from 0 + to 10 evaluating on completion, quality, and overall performance- Entities extracted + from the task output, if any, their type, description, and relationships"}], + "model": "gpt-4o-mini", "tool_choice": {"type": "function", "function": {"name": + "TaskEvaluation"}}, "tools": [{"type": "function", "function": {"name": "TaskEvaluation", + "description": "Correctly extracted `TaskEvaluation` with all the required parameters + with correct types", "parameters": {"$defs": {"Entity": {"properties": {"name": + {"description": "The name of the entity.", "title": "Name", "type": "string"}, + "type": {"description": "The type of the entity.", "title": "Type", "type": + "string"}, "description": {"description": "Description of the entity.", "title": + "Description", "type": "string"}, "relationships": {"description": "Relationships + of the entity.", "items": {"type": "string"}, "title": "Relationships", "type": + "array"}}, "required": ["name", "type", "description", "relationships"], "title": + "Entity", "type": "object"}}, "properties": {"suggestions": {"description": + "Suggestions to improve future similar tasks.", "items": {"type": "string"}, + "title": "Suggestions", "type": "array"}, "quality": {"description": "A score + from 0 to 10 evaluating on completion, quality, and overall performance, all + taking into account the task description, expected output, and the result of + the task.", "title": "Quality", "type": "number"}, "entities": {"description": + "Entities extracted from the task output.", "items": {"$ref": "#/$defs/Entity"}, + "title": "Entities", "type": "array"}}, "required": ["entities", "quality", + "suggestions"], "type": "object"}}}]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '3122' + content-type: + - application/json + cookie: + - __cf_bm=nSje5Zn_Lk69BDG85XIauC2hrZjGl0pR2sel9__KWGw-1744489610-1.0.1.1-CPlAgcgTAE30uWrbi_2wiCWrbRDRWiaa.YuQMgST42DLDVg_wdNlJMDQT3Lsqk.g.BO68A66TTirWA0blQaQw.9xdBbPwKO609_ftjdwi5U; + _cfuvid=XLC52GLAWCOeWn2vI379CnSGKjPa7f.qr2vSAQ_R66M-1744489610542-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BLbjPDVXbx6ZqnKWoFyZrOANttRhy\",\n \"object\": + \"chat.completion\",\n \"created\": 1744489627,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": null,\n \"tool_calls\": [\n {\n + \ \"id\": \"call_eAkZTqgRjMf5sT0YsJE0qKb6\",\n \"type\": + \"function\",\n \"function\": {\n \"name\": \"TaskEvaluation\",\n + \ \"arguments\": \"{\\\"suggestions\\\":[\\\"Ensure the output clearly + lists URLs related to the specified topics without irrelevant text.\\\",\\\"Confirm + the relevance of each URL to the topics mentioned to ensure quality of information + provided.\\\",\\\"Avoid including filler statements that do not contribute to + the task result.\\\"],\\\"quality\\\":8,\\\"entities\\\":[{\\\"name\\\":\\\"Artificial + Intelligence Ethics\\\",\\\"type\\\":\\\"Topic\\\",\\\"description\\\":\\\"Ethical + considerations surrounding artificial intelligence and its impact on society.\\\",\\\"relationships\\\":[\\\"Related + to technology ethics\\\",\\\"Relevant to discussions on AI technologies\\\"]},{\\\"name\\\":\\\"Impact + of 5G Technology\\\",\\\"type\\\":\\\"Technology\\\",\\\"description\\\":\\\"The + effects and implications of 5G technology in various sectors.\\\",\\\"relationships\\\":[\\\"Related + to telecommunications\\\",\\\"Connected to advancements in mobile technology\\\"]},{\\\"name\\\":\\\"Quantum + Computing Developments\\\",\\\"type\\\":\\\"Field\\\",\\\"description\\\":\\\"Recent + advancements and research in quantum computing technology.\\\",\\\"relationships\\\":[\\\"Related + to computing technology\\\",\\\"Connected to artificial intelligence\\\"]},{\\\"name\\\":\\\"Cybersecurity + Trends 2023\\\",\\\"type\\\":\\\"Trend\\\",\\\"description\\\":\\\"Current trends + and developments in the field of cybersecurity for the year 2023.\\\",\\\"relationships\\\":[\\\"Related + to security technology\\\",\\\"Connected to IT management\\\"]},{\\\"name\\\":\\\"Sustainable + Technology Innovations\\\",\\\"type\\\":\\\"Innovation\\\",\\\"description\\\":\\\"Innovations + and technologies aimed at achieving sustainability in various industries.\\\",\\\"relationships\\\":[\\\"Related + to environmental technology\\\",\\\"Connected to technological advancements + in sustainability\\\"]}]}\"\n }\n }\n ],\n \"refusal\": + null,\n \"annotations\": []\n },\n \"logprobs\": null,\n \"finish_reason\": + \"stop\"\n }\n ],\n \"usage\": {\n \"prompt_tokens\": 585,\n \"completion_tokens\": + 259,\n \"total_tokens\": 844,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_44added55e\"\n}\n" + headers: + CF-RAY: + - 92f5766c3dd47e05-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:13 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '5720' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999606' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_6bdc999e371bbd553ebd496d61e6e927 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Artificial Intelligence Ethics(Topic): Ethical considerations + surrounding artificial intelligence and its impact on society."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '203' + content-type: + - application/json + cookie: + - __cf_bm=cR3UB8mqarbHmGoKX4j_dGO4qF39Epoc9INuvxf_oYw-1744489622-1.0.1.1-4KvvhHXyjYp0xWmM8C4keAQYtI32ipHCW7aBSiQSz9Ef2uz1cF.gEHWXcsIwbU2JmaVvRKP2CmAISkzMWc0CfrwjHlah52qvvbqETbaM348; + _cfuvid=ENTtDEni.J8Fwif2S5LczePrB2zgM0X0vYqXgEVD6.E-1744489622943-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 19,\n \"total_tokens\": 19\n }\n}\n" + headers: + CF-RAY: + - 92f57691591e7e0a-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:13 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '130' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-cbdb5c968-dcbgr + x-envoy-upstream-service-time: + - '80' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999968' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_a1890d40918f8e603ff51cfdaf00f240 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Impact of 5G Technology(Technology): The effects and implications + of 5G technology in various sectors."], "model": "text-embedding-3-small", "encoding_format": + "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '181' + content-type: + - application/json + cookie: + - __cf_bm=cR3UB8mqarbHmGoKX4j_dGO4qF39Epoc9INuvxf_oYw-1744489622-1.0.1.1-4KvvhHXyjYp0xWmM8C4keAQYtI32ipHCW7aBSiQSz9Ef2uz1cF.gEHWXcsIwbU2JmaVvRKP2CmAISkzMWc0CfrwjHlah52qvvbqETbaM348; + _cfuvid=ENTtDEni.J8Fwif2S5LczePrB2zgM0X0vYqXgEVD6.E-1744489622943-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 24,\n \"total_tokens\": 24\n }\n}\n" + headers: + CF-RAY: + - 92f576948af07e0a-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:14 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '106' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-cbdb5c968-6m9q9 + x-envoy-upstream-service-time: + - '77' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999974' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_b3c8022893e9f0426bf37a81e6ef154b + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Quantum Computing Developments(Field): Recent advancements + and research in quantum computing technology."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '183' + content-type: + - application/json + cookie: + - __cf_bm=cR3UB8mqarbHmGoKX4j_dGO4qF39Epoc9INuvxf_oYw-1744489622-1.0.1.1-4KvvhHXyjYp0xWmM8C4keAQYtI32ipHCW7aBSiQSz9Ef2uz1cF.gEHWXcsIwbU2JmaVvRKP2CmAISkzMWc0CfrwjHlah52qvvbqETbaM348; + _cfuvid=ENTtDEni.J8Fwif2S5LczePrB2zgM0X0vYqXgEVD6.E-1744489622943-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 16,\n \"total_tokens\": 16\n }\n}\n" + headers: + CF-RAY: + - 92f576970cb67e0a-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:14 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '67' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-5f88c6c559-sp2t5 + x-envoy-upstream-service-time: + - '39' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999973' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_0bf685ff90824bc7c3a0722f1b99df5e + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Cybersecurity Trends 2023(Trend): Current trends and developments + in the field of cybersecurity for the year 2023."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '193' + content-type: + - application/json + cookie: + - __cf_bm=cR3UB8mqarbHmGoKX4j_dGO4qF39Epoc9INuvxf_oYw-1744489622-1.0.1.1-4KvvhHXyjYp0xWmM8C4keAQYtI32ipHCW7aBSiQSz9Ef2uz1cF.gEHWXcsIwbU2JmaVvRKP2CmAISkzMWc0CfrwjHlah52qvvbqETbaM348; + _cfuvid=ENTtDEni.J8Fwif2S5LczePrB2zgM0X0vYqXgEVD6.E-1744489622943-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 26,\n \"total_tokens\": 26\n }\n}\n" + headers: + CF-RAY: + - 92f5769a5f287e0a-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:15 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '80' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-6db676c665-97cfs + x-envoy-upstream-service-time: + - '59' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999972' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_51016d492babf4fda2160885c66acac5 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Sustainable Technology Innovations(Innovation): Innovations + and technologies aimed at achieving sustainability in various industries."], + "model": "text-embedding-3-small", "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '212' + content-type: + - application/json + cookie: + - __cf_bm=cR3UB8mqarbHmGoKX4j_dGO4qF39Epoc9INuvxf_oYw-1744489622-1.0.1.1-4KvvhHXyjYp0xWmM8C4keAQYtI32ipHCW7aBSiQSz9Ef2uz1cF.gEHWXcsIwbU2JmaVvRKP2CmAISkzMWc0CfrwjHlah52qvvbqETbaM348; + _cfuvid=ENTtDEni.J8Fwif2S5LczePrB2zgM0X0vYqXgEVD6.E-1744489622943-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 20,\n \"total_tokens\": 20\n }\n}\n" + headers: + CF-RAY: + - 92f5769d89287e0a-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:15 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '132' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-6db676c665-xtlbt + x-envoy-upstream-service-time: + - '114' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999967' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_e0b0b5be5e41cb0418a78bcd601d514c + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/cassettes/test_crew_external_memory_save_with_memory_flag[search].yaml b/tests/cassettes/test_crew_external_memory_save_with_memory_flag[search].yaml new file mode 100644 index 000000000..9d652fd0a --- /dev/null +++ b/tests/cassettes/test_crew_external_memory_save_with_memory_flag[search].yaml @@ -0,0 +1,1425 @@ +interactions: +- request: + body: '{"input": ["Perform a search on specific topics."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '115' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 7,\n \"total_tokens\": 7\n }\n}\n" + headers: + CF-RAY: + - 92f575b5ddc27dec-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:26:39 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=FIPwcipZP4faG6u.UZ0VUbpQ15Dz4z8_QZv_6xQ0GQM-1744489599-1.0.1.1-UMdQ71ibozWnbxUEtzIovmFjiHG47RkgSeWISeEjCz8p4jepJs3llWKL5qXOZp4v2nxvO9Npb07uVJlGiIB63CBiTcqNmiGu.5DcDJJl02w; + path=/; expires=Sat, 12-Apr-25 20:56:39 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=gDsKzGTdfritvzjX7P3jkxQy1tBIdZR8876FolHrzTY-1744489599196-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '241' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-7d86d58f9c-fmk2c + x-envoy-upstream-service-time: + - '164' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999991' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_f50f5433d6ac755239a8c9707348b72f + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Perform a search on specific topics."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '115' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 7,\n \"total_tokens\": 7\n }\n}\n" + headers: + CF-RAY: + - 92f575bb3c007dfe-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:26:40 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=Jm73zgaX93R7dmdHzthaQLZvS.FDTE7mV9FjnnXOzfk-1744489600-1.0.1.1-PoukpcSnzv7SStgVNleiuwDs4T5hZv9FaVqJkkBq_o1SOXnoQ4d4zSCJ2.fmyc8TLrPx1Ykh1NK4D13sIHXLKj5Oic8deea9HMeiDr3X4y0; + path=/; expires=Sat, 12-Apr-25 20:56:40 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=_e.uFVx98Z8p0BNXXGWGZiyLKJW8yG7vjquHkWxJXnI-1744489600237-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '119' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-54db47bfc6-vjbpf + x-envoy-upstream-service-time: + - '80' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999991' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_1bf27e828b7268ecd56800819bff96c0 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: !!binary | + Ct8MCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkStgwKEgoQY3Jld2FpLnRl + bGVtZXRyeRKcCAoQX0YRUL8eiOdyMZ9UyG+SGxIIqZnu2Hw5xU8qDENyZXcgQ3JlYXRlZDABOXD+ + LfkLrDUYQfAGN/kLrDUYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGgoOcHl0aG9uX3Zl + cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIDA3YTcxNzY4Y2M0YzkzZWFiM2IzMWUzYzhk + MjgzMmM2SjEKB2NyZXdfaWQSJgokZjQzMGJiYTUtYWNmNS00NjRiLWJjMzMtYThjMDkxMWFiN2Yy + ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAUoaChRjcmV3 + X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3 + X2ZpbmdlcnByaW50EiYKJDIxYjUyYTc5LTlmZTMtNDI5Ny05OTZlLTNiNGQ3MjIxMGI4OUo7Chtj + cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xMlQxNzoyNjozOC4wMzIwMDdK + 0AIKC2NyZXdfYWdlbnRzEsACCr0CW3sia2V5IjogIjAyZGYxM2UzNjcxMmFiZjUxZDIzOGZlZWJh + YjFjYTI2IiwgImlkIjogIjYyOTVhZTk5LTg5ZjAtNDA5Yi1iMmEwLTdiYzBjYWE1M2VmOSIsICJy + b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiB0cnVlLCAibWF4X2l0ZXIiOiAyNSwgIm1h + eF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8t + bWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlv + bj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtdfV1K/wEK + CmNyZXdfdGFza3MS8AEK7QFbeyJrZXkiOiAiN2I0MmRmM2MzYzc0YzIxYzg5NDgwZTBjMDcwNTM4 + NWYiLCAiaWQiOiAiNTM2ODI0YzYtNzAzOC00ODk0LTk0MjItZDEwOTc1MWNkMTJmIiwgImFzeW5j + X2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6 + ICJSZXNlYXJjaGVyIiwgImFnZW50X2tleSI6ICIwMmRmMTNlMzY3MTJhYmY1MWQyMzhmZWViYWIx + Y2EyNiIsICJ0b29sc19uYW1lcyI6IFtdfV16AhgBhQEAAQAAEoAEChBHv769lTpKECHWsnSuLOyr + EgjzK09Rxkmd2yoMVGFzayBDcmVhdGVkMAE5OLlB+QusNRhBWAdC+QusNRhKLgoIY3Jld19rZXkS + IgogMDdhNzE3NjhjYzRjOTNlYWIzYjMxZTNjOGQyODMyYzZKMQoHY3Jld19pZBImCiRmNDMwYmJh + NS1hY2Y1LTQ2NGItYmMzMy1hOGMwOTExYWI3ZjJKLgoIdGFza19rZXkSIgogN2I0MmRmM2MzYzc0 + YzIxYzg5NDgwZTBjMDcwNTM4NWZKMQoHdGFza19pZBImCiQ1MzY4MjRjNi03MDM4LTQ4OTQtOTQy + Mi1kMTA5NzUxY2QxMmZKOgoQY3Jld19maW5nZXJwcmludBImCiQyMWI1MmE3OS05ZmUzLTQyOTct + OTk2ZS0zYjRkNzIyMTBiODlKOgoQdGFza19maW5nZXJwcmludBImCiQyOGQyMmViOC0zOGU2LTQ5 + Y2UtYmUyNy1jOTlkYzcwYTUwOGRKOwobdGFza19maW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIw + MjUtMDQtMTJUMTc6MjY6MzguMDMxOTc2SjsKEWFnZW50X2ZpbmdlcnByaW50EiYKJGI1YTEwYjRl + LWQ1YWMtNDBmMS1iMThlLTJhODUxY2ZiNTdkYnoCGAGFAQABAAA= + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '1634' + Content-Type: + - application/x-protobuf + User-Agent: + - OTel-OTLP-Exporter-Python/1.31.1 + 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: + - Sat, 12 Apr 2025 20:26:41 GMT + status: + code: 200 + message: OK +- request: + body: '{"messages": [{"role": "system", "content": "You are Researcher. You are + a researcher at a leading tech think tank.\nYour personal goal is: Search relevant + data and provide results\nTo give my best complete final answer to the task + respond using 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 complete + as possible, it must be outcome described.\n\nI MUST use these formats, my job + depends on it!"}, {"role": "user", "content": "\nCurrent Task: Perform a search + on specific topics.\n\nThis is the expected criteria for your final answer: + A list of relevant URLs based on the search query.\nyou MUST return the actual + complete content as the final answer, not a summary.\n\n# Useful context: \nExternal + memories:\n\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:"}], "model": + "gpt-4o-mini", "stop": ["\nObservation:"]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '989' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BLbiyMGQm6ZA3CZgBhUncdqsW8Ru4\",\n \"object\": + \"chat.completion\",\n \"created\": 1744489600,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": \"I now can give a great answer \\nFinal + Answer: \\n\\n1. **Artificial Intelligence in Healthcare**\\n - URL: [https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7073215/](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7073215/) + - This article explores various applications of AI in healthcare, including + diagnostics and treatment personalization.\\n\\n2. **Blockchain Technology and + Its Impact on Supply Chain**\\n - URL: [https://www.researchgate.net/publication/341717309_Blockchain_Technology_in_Supply_Chain_Management](https://www.researchgate.net/publication/341717309_Blockchain_Technology_in_Supply_Chain_Management) + - This research paper discusses the potential of blockchain in enhancing supply + chain transparency and efficiency.\\n\\n3. **Cybersecurity Trends for 2023**\\n + \ - URL: [https://www.cybersecurity-insiders.com/cybersecurity-trends-2023/](https://www.cybersecurity-insiders.com/cybersecurity-trends-2023/) + - This resource outlines the major cybersecurity trends expected to shape the + industry in 2023, including emerging threats and mitigation strategies.\\n\\n4. + **The Impact of Remote Work on Productivity**\\n - URL: [https://www.mitpressjournals.org/doi/full/10.1162/99608f92.2020.12.01](https://www.mitpressjournals.org/doi/full/10.1162/99608f92.2020.12.01) + - This journal article provides insights into how remote work affects productivity, + work-life balance, and organizational dynamics.\\n\\n5. **Quantum Computing: + A Beginner's Guide**\\n - URL: [https://www.ibm.com/quantum-computing/learn/what-is-quantum-computing/](https://www.ibm.com/quantum-computing/learn/what-is-quantum-computing/) + - This resource serves as an introduction to quantum computing, detailing its + principles and potential applications.\\n\\n6. **Sustainable Energy Technologies + for the Future**\\n - URL: [https://www.energy.gov/eere/solar/articles/sustainable-energy-technology-future](https://www.energy.gov/eere/solar/articles/sustainable-energy-technology-future) + - This article discusses various sustainable energy technologies that could + play a crucial role in future energy landscapes.\\n\\n7. **5G Technology and + Its Implications**\\n - URL: [https://www.qualcomm.com/invention/5g/what-is-5g](https://www.qualcomm.com/invention/5g/what-is-5g) + - This page explains what 5G technology is and explores its potential implications + for various sectors including telecommunications and the Internet of Things + (IoT). \\n\\nThese resources have been carefully selected to meet the specified + topics and provide comprehensive insights.\",\n \"refusal\": null,\n + \ \"annotations\": []\n },\n \"logprobs\": null,\n \"finish_reason\": + \"stop\"\n }\n ],\n \"usage\": {\n \"prompt_tokens\": 185,\n \"completion_tokens\": + 598,\n \"total_tokens\": 783,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_80cf447eee\"\n}\n" + headers: + CF-RAY: + - 92f575c23de77dff-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:26:50 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=nSje5Zn_Lk69BDG85XIauC2hrZjGl0pR2sel9__KWGw-1744489610-1.0.1.1-CPlAgcgTAE30uWrbi_2wiCWrbRDRWiaa.YuQMgST42DLDVg_wdNlJMDQT3Lsqk.g.BO68A66TTirWA0blQaQw.9xdBbPwKO609_ftjdwi5U; + path=/; expires=Sat, 12-Apr-25 20:56:50 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=XLC52GLAWCOeWn2vI379CnSGKjPa7f.qr2vSAQ_R66M-1744489610542-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '9693' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999788' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_b4e0a78aa1862709077bd91cf4a45064 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["I now can give a great answer Final Answer: 1. **Artificial + Intelligence in Healthcare** - URL: [https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7073215/](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7073215/) + - This article explores various applications of AI in healthcare, including + diagnostics and treatment personalization. 2. **Blockchain Technology and Its + Impact on Supply Chain** - URL: [https://www.researchgate.net/publication/341717309_Blockchain_Technology_in_Supply_Chain_Management](https://www.researchgate.net/publication/341717309_Blockchain_Technology_in_Supply_Chain_Management) + - This research paper discusses the potential of blockchain in enhancing supply + chain transparency and efficiency. 3. **Cybersecurity Trends for 2023** - + URL: [https://www.cybersecurity-insiders.com/cybersecurity-trends-2023/](https://www.cybersecurity-insiders.com/cybersecurity-trends-2023/) + - This resource outlines the major cybersecurity trends expected to shape the + industry in 2023, including emerging threats and mitigation strategies. 4. + **The Impact of Remote Work on Productivity** - URL: [https://www.mitpressjournals.org/doi/full/10.1162/99608f92.2020.12.01](https://www.mitpressjournals.org/doi/full/10.1162/99608f92.2020.12.01) + - This journal article provides insights into how remote work affects productivity, + work-life balance, and organizational dynamics. 5. **Quantum Computing: A Beginner''s + Guide** - URL: [https://www.ibm.com/quantum-computing/learn/what-is-quantum-computing/](https://www.ibm.com/quantum-computing/learn/what-is-quantum-computing/) + - This resource serves as an introduction to quantum computing, detailing its + principles and potential applications. 6. **Sustainable Energy Technologies + for the Future** - URL: [https://www.energy.gov/eere/solar/articles/sustainable-energy-technology-future](https://www.energy.gov/eere/solar/articles/sustainable-energy-technology-future) + - This article discusses various sustainable energy technologies that could + play a crucial role in future energy landscapes. 7. **5G Technology and Its + Implications** - URL: [https://www.qualcomm.com/invention/5g/what-is-5g](https://www.qualcomm.com/invention/5g/what-is-5g) + - This page explains what 5G technology is and explores its potential implications + for various sectors including telecommunications and the Internet of Things + (IoT). These resources have been carefully selected to meet the specified + topics and provide comprehensive insights."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '2571' + content-type: + - application/json + cookie: + - __cf_bm=FIPwcipZP4faG6u.UZ0VUbpQ15Dz4z8_QZv_6xQ0GQM-1744489599-1.0.1.1-UMdQ71ibozWnbxUEtzIovmFjiHG47RkgSeWISeEjCz8p4jepJs3llWKL5qXOZp4v2nxvO9Npb07uVJlGiIB63CBiTcqNmiGu.5DcDJJl02w; + _cfuvid=gDsKzGTdfritvzjX7P3jkxQy1tBIdZR8876FolHrzTY-1744489599196-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 606,\n \"total_tokens\": 606\n }\n}\n" + headers: + CF-RAY: + - 92f57602bbdf7e0d-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:26:51 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '278' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-6db676c665-kppq9 + x-envoy-upstream-service-time: + - '234' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999376' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 3ms + x-request-id: + - req_030874a7f102fccbecd0742b5caa51e6 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"messages": [{"role": "user", "content": "Assess the quality of the task + completed based on the description, expected output, and actual results.\n\nTask + Description:\nPerform a search on specific topics.\n\nExpected Output:\nA list + of relevant URLs based on the search query.\n\nActual Output:\nI now can give + a great answer \nFinal Answer: \n\n1. **Artificial Intelligence in Healthcare**\n - + URL: [https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7073215/](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7073215/) + - This article explores various applications of AI in healthcare, including + diagnostics and treatment personalization.\n\n2. **Blockchain Technology and + Its Impact on Supply Chain**\n - URL: [https://www.researchgate.net/publication/341717309_Blockchain_Technology_in_Supply_Chain_Management](https://www.researchgate.net/publication/341717309_Blockchain_Technology_in_Supply_Chain_Management) + - This research paper discusses the potential of blockchain in enhancing supply + chain transparency and efficiency.\n\n3. **Cybersecurity Trends for 2023**\n - + URL: [https://www.cybersecurity-insiders.com/cybersecurity-trends-2023/](https://www.cybersecurity-insiders.com/cybersecurity-trends-2023/) + - This resource outlines the major cybersecurity trends expected to shape the + industry in 2023, including emerging threats and mitigation strategies.\n\n4. + **The Impact of Remote Work on Productivity**\n - URL: [https://www.mitpressjournals.org/doi/full/10.1162/99608f92.2020.12.01](https://www.mitpressjournals.org/doi/full/10.1162/99608f92.2020.12.01) + - This journal article provides insights into how remote work affects productivity, + work-life balance, and organizational dynamics.\n\n5. **Quantum Computing: A + Beginner''s Guide**\n - URL: [https://www.ibm.com/quantum-computing/learn/what-is-quantum-computing/](https://www.ibm.com/quantum-computing/learn/what-is-quantum-computing/) + - This resource serves as an introduction to quantum computing, detailing its + principles and potential applications.\n\n6. **Sustainable Energy Technologies + for the Future**\n - URL: [https://www.energy.gov/eere/solar/articles/sustainable-energy-technology-future](https://www.energy.gov/eere/solar/articles/sustainable-energy-technology-future) + - This article discusses various sustainable energy technologies that could + play a crucial role in future energy landscapes.\n\n7. **5G Technology and Its + Implications**\n - URL: [https://www.qualcomm.com/invention/5g/what-is-5g](https://www.qualcomm.com/invention/5g/what-is-5g) + - This page explains what 5G technology is and explores its potential implications + for various sectors including telecommunications and the Internet of Things + (IoT). \n\nThese resources have been carefully selected to meet the specified + topics and provide comprehensive insights.\n\nPlease provide:\n- Bullet points + suggestions to improve future similar tasks\n- A score from 0 to 10 evaluating + on completion, quality, and overall performance- Entities extracted from the + task output, if any, their type, description, and relationships"}], "model": + "gpt-4o-mini", "tool_choice": {"type": "function", "function": {"name": "TaskEvaluation"}}, + "tools": [{"type": "function", "function": {"name": "TaskEvaluation", "description": + "Correctly extracted `TaskEvaluation` with all the required parameters with + correct types", "parameters": {"$defs": {"Entity": {"properties": {"name": {"description": + "The name of the entity.", "title": "Name", "type": "string"}, "type": {"description": + "The type of the entity.", "title": "Type", "type": "string"}, "description": + {"description": "Description of the entity.", "title": "Description", "type": + "string"}, "relationships": {"description": "Relationships of the entity.", + "items": {"type": "string"}, "title": "Relationships", "type": "array"}}, "required": + ["name", "type", "description", "relationships"], "title": "Entity", "type": + "object"}}, "properties": {"suggestions": {"description": "Suggestions to improve + future similar tasks.", "items": {"type": "string"}, "title": "Suggestions", + "type": "array"}, "quality": {"description": "A score from 0 to 10 evaluating + on completion, quality, and overall performance, all taking into account the + task description, expected output, and the result of the task.", "title": "Quality", + "type": "number"}, "entities": {"description": "Entities extracted from the + task output.", "items": {"$ref": "#/$defs/Entity"}, "title": "Entities", "type": + "array"}}, "required": ["entities", "quality", "suggestions"], "type": "object"}}}]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '4549' + content-type: + - application/json + cookie: + - __cf_bm=nSje5Zn_Lk69BDG85XIauC2hrZjGl0pR2sel9__KWGw-1744489610-1.0.1.1-CPlAgcgTAE30uWrbi_2wiCWrbRDRWiaa.YuQMgST42DLDVg_wdNlJMDQT3Lsqk.g.BO68A66TTirWA0blQaQw.9xdBbPwKO609_ftjdwi5U; + _cfuvid=XLC52GLAWCOeWn2vI379CnSGKjPa7f.qr2vSAQ_R66M-1744489610542-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BLbjARfvpsFHRIcsRy1tkoLnzgoND\",\n \"object\": + \"chat.completion\",\n \"created\": 1744489612,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": null,\n \"tool_calls\": [\n {\n + \ \"id\": \"call_NWNQXwfvDMoLSvt0qFPlk5so\",\n \"type\": + \"function\",\n \"function\": {\n \"name\": \"TaskEvaluation\",\n + \ \"arguments\": \"{\\\"suggestions\\\":[\\\"Ensure the search query + is clearly defined to better guide the selection of URLs.\\\",\\\"Provide a + brief summary or context for each URL to enhance relevance and understanding.\\\",\\\"Use + a consistent format for URL presentation, possibly including the title in a + uniform manner.\\\",\\\"Consider including a wider variety of sources (peer-reviewed + articles, news sites, etc.) for a more comprehensive output.\\\",\\\"Verify + the quality and credibility of the URLs before including them.\\\"],\\\"quality\\\":9,\\\"entities\\\":[{\\\"name\\\":\\\"Artificial + Intelligence in Healthcare\\\",\\\"type\\\":\\\"Topic\\\",\\\"description\\\":\\\"Exploration + of AI applications in healthcare, including diagnostics and treatment.\\\",\\\"relationships\\\":[\\\"Has + URL\\\",\\\"Is relevant to healthcare advancements\\\"]},{\\\"name\\\":\\\"Blockchain + Technology\\\",\\\"type\\\":\\\"Topic\\\",\\\"description\\\":\\\"Impact of + blockchain on supply chain management.\\\",\\\"relationships\\\":[\\\"Has URL\\\",\\\"Is + relevant to supply chain technology\\\"]},{\\\"name\\\":\\\"Cybersecurity Trends + for 2023\\\",\\\"type\\\":\\\"Topic\\\",\\\"description\\\":\\\"Key trends expected + in the cybersecurity field for the year 2023.\\\",\\\"relationships\\\":[\\\"Has + URL\\\",\\\"Is relevant to cybersecurity awareness\\\"]},{\\\"name\\\":\\\"Impact + of Remote Work on Productivity\\\",\\\"type\\\":\\\"Topic\\\",\\\"description\\\":\\\"Effects + of remote work on productivity and organizational dynamics.\\\",\\\"relationships\\\":[\\\"Has + URL\\\",\\\"Is relevant to work-life balance discussions\\\"]},{\\\"name\\\":\\\"Quantum + Computing\\\",\\\"type\\\":\\\"Topic\\\",\\\"description\\\":\\\"Introduction + to the principles and applications of quantum computing.\\\",\\\"relationships\\\":[\\\"Has + URL\\\",\\\"Is relevant to advancements in computing technology\\\"]},{\\\"name\\\":\\\"Sustainable + Energy Technologies\\\",\\\"type\\\":\\\"Topic\\\",\\\"description\\\":\\\"Technologies + that contribute to sustainable energy solutions.\\\",\\\"relationships\\\":[\\\"Has + URL\\\",\\\"Is relevant to future energy discussions\\\"]},{\\\"name\\\":\\\"5G + Technology\\\",\\\"type\\\":\\\"Topic\\\",\\\"description\\\":\\\"Explanation + of 5G technology and its implications for various sectors.\\\",\\\"relationships\\\":[\\\"Has + URL\\\",\\\"Is relevant to telecommunications advancements\\\"]}]}\"\n }\n + \ }\n ],\n \"refusal\": null,\n \"annotations\": + []\n },\n \"logprobs\": null,\n \"finish_reason\": \"stop\"\n + \ }\n ],\n \"usage\": {\n \"prompt_tokens\": 879,\n \"completion_tokens\": + 354,\n \"total_tokens\": 1233,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_44added55e\"\n}\n" + headers: + CF-RAY: + - 92f57609ea7f7dff-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:26:56 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '4323' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999249' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_cf14ba71ebe0bb5b3353c5204210a419 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Artificial Intelligence in Healthcare(Topic): Exploration of + AI applications in healthcare, including diagnostics and treatment."], "model": + "text-embedding-3-small", "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '207' + content-type: + - application/json + cookie: + - __cf_bm=Jm73zgaX93R7dmdHzthaQLZvS.FDTE7mV9FjnnXOzfk-1744489600-1.0.1.1-PoukpcSnzv7SStgVNleiuwDs4T5hZv9FaVqJkkBq_o1SOXnoQ4d4zSCJ2.fmyc8TLrPx1Ykh1NK4D13sIHXLKj5Oic8deea9HMeiDr3X4y0; + _cfuvid=_e.uFVx98Z8p0BNXXGWGZiyLKJW8yG7vjquHkWxJXnI-1744489600237-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 20,\n \"total_tokens\": 20\n }\n}\n" + headers: + CF-RAY: + - 92f5762688a27df4-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:26:56 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '53' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-569c8b5ffc-kjrfn + x-envoy-upstream-service-time: + - '36' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999967' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_56a888d0aed276f463e06d086a625c3b + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Blockchain Technology(Topic): Impact of blockchain on supply + chain management."], "model": "text-embedding-3-small", "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '157' + content-type: + - application/json + cookie: + - __cf_bm=Jm73zgaX93R7dmdHzthaQLZvS.FDTE7mV9FjnnXOzfk-1744489600-1.0.1.1-PoukpcSnzv7SStgVNleiuwDs4T5hZv9FaVqJkkBq_o1SOXnoQ4d4zSCJ2.fmyc8TLrPx1Ykh1NK4D13sIHXLKj5Oic8deea9HMeiDr3X4y0; + _cfuvid=_e.uFVx98Z8p0BNXXGWGZiyLKJW8yG7vjquHkWxJXnI-1744489600237-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 13,\n \"total_tokens\": 13\n }\n}\n" + headers: + CF-RAY: + - 92f5762afb707df4-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:26:57 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '118' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-5d57948d5d-4zlnq + x-envoy-upstream-service-time: + - '76' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999980' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_6ddb9bc394617365d7b16f4acf8f2e14 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Cybersecurity Trends for 2023(Topic): Key trends expected in + the cybersecurity field for the year 2023."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '182' + content-type: + - application/json + cookie: + - __cf_bm=Jm73zgaX93R7dmdHzthaQLZvS.FDTE7mV9FjnnXOzfk-1744489600-1.0.1.1-PoukpcSnzv7SStgVNleiuwDs4T5hZv9FaVqJkkBq_o1SOXnoQ4d4zSCJ2.fmyc8TLrPx1Ykh1NK4D13sIHXLKj5Oic8deea9HMeiDr3X4y0; + _cfuvid=_e.uFVx98Z8p0BNXXGWGZiyLKJW8yG7vjquHkWxJXnI-1744489600237-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 25,\n \"total_tokens\": 25\n }\n}\n" + headers: + CF-RAY: + - 92f5762ffeb57df4-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:26:58 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '312' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-6c4b45ffdf-cwsls + x-envoy-upstream-service-time: + - '252' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999974' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_1a390dcc4e0ad9dfc99301a765d763d2 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Impact of Remote Work on Productivity(Topic): Effects of remote + work on productivity and organizational dynamics."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '192' + content-type: + - application/json + cookie: + - __cf_bm=Jm73zgaX93R7dmdHzthaQLZvS.FDTE7mV9FjnnXOzfk-1744489600-1.0.1.1-PoukpcSnzv7SStgVNleiuwDs4T5hZv9FaVqJkkBq_o1SOXnoQ4d4zSCJ2.fmyc8TLrPx1Ykh1NK4D13sIHXLKj5Oic8deea9HMeiDr3X4y0; + _cfuvid=_e.uFVx98Z8p0BNXXGWGZiyLKJW8yG7vjquHkWxJXnI-1744489600237-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"iD7IPCw5AD3qQGg98iGIPaK8hjwI0Xg8DyolPdbWpjwe6jk8qO6mPOUeLzzvtUw8uT9YO9krvbzK4zQ8mY95PP7BzjpXATK9F7iZO9dX3DzDZSc8CXARPeycvDv3f8c8zn36O1D7MD09ijG9cq36PMnTzTxKUQQ8BozJvAEuirxlOdO7WpJOvY7/mToKeTo9skm+PJmPeTwO3rc86L8yPG5IfTx+a6S7E48iPPCJLT1F3B+9O0UCOxK7QbzqyNs8KmWfPXoGpzyYlje63yHXvLbqwTrykla9f+zZvAOvvzwQdhK6z1gZPFnVEr1CNN67hvmYPfTuqr0yoGg9VCQoPcLdM7y04Ri9WpJOvSGLPbxEVCy9Gf3IvJ6TDzyw7Wk8EavaO/HVGj3YZ8M7V3k+u5jSvTsimyS9qoYBPDJrILy/cXi4zxwTvNkkfzwLPTQ8vrQ8vMgWkryGpm27p6I5vemDrLxNU+84uhM5vAdgqrl6Bqc8/LglPJmP+TujeUK94fW3PP+VLz2xBI+85+vRPHYZNj3DZae8WE0fvaURnTrIngU8g1iVPAlwETw1SCq8F2XuvCbp/LyjecK9llEIuj5eEr1N4qA8M7BPvRSIZL2Ns6y8ovFOu6Dopbxef7+8qJv7vL9xeD2x/VA8cngyPZ4bgzy5kgO8dEVVvQ+b87vemWO9czXuvK2fkT1nlSe8sXXdPGhpCL15Msa8je8yvOa2Cb0XMKY7qCPvvCXwOjtFoJk89F95PJw3Ozx6yiA7m6/HvCW0tDwcaQQ920sLPT2KsTz0Zjc8RRHoO1G47LzQnci7/QQTvceOHj1hJwE9iiKQO1xfcbtHIU+8VKwbu2s2K7u8lG48DNUOvdxETbzpgyy7f2RmOzcci7utEOA8cwAmvX/sWbxPNze9/Cl0vSGLvTtWLdE8e1KUu3eaa7yDUde8zLDXPMug8DzcRM083yHXvExarbzvtcy8plZMvdPyXr3BkUa9W6I1vc8cEz0Fkwe93MzAuy32uzx0mAC9GO1hO3YZtrxhnw08qcKHOqq7Sbx8D9C31HrSvCMM87y/iJ09v4gdPW5IfT0QI2e8OjUbPWu+nrw3jdk8TuvJOodFBru0yvM8soXEPCSri7tfPHs8W2avPD7PYD2qhoG9hNnKun5U/zw6+ZQ83Yn8PHKtejvoc8W8wPlru+SWuzxMy/s8dc3IPGKotjxiqDa9aBZdPcKhLb2RGCo8zn36uvjLNDz5TOq7YZ+NPC9SEL3qGwc9v3F4vFSV9jtVcJW8i+YJPTWEsDts8+a7xObcuyrdq7oDN7M6o3lCvMMpobyXSkq94e55vXftFj3mtgk8xrP/O0L/FT1akk47Sv5YvTN7B73T8t479XYePbVpjD3xESG9nfT2u5uvxzwGjEk82sOXvDLzkzyan2A98AG6PCxuyLzBkca8M7eNPXHwvjyGcSW9KtZtvCAKCL307io9TrYBvNR6UrwMTRu9Pl4Svc3APjz0X/k7OJ3AO9fmDb3Fur08kU3yO8Tm3LtEVKw9OJ1AvCQc2jzjFQa95tvqPDQ4Qzy4t+S8nozRPAhZbL1JBZc9d+2WPMNeab0FCxQ8NxVNPdNq67y9LMm8dBCNPBN4/Tw5Wny8z43hO6bO2Lwj5xE8F7iZvAn4BD0/V9Q8/TlbPfX+ETyw9Ce9nQscPEepwjxr4/87LG5IvKmrYrxO60m9HFJfvfGCbzxIZn69aS0CPX0fNzoaDTA8jCu5PEqNirvbD4U7zwXuvOhzRT2atgU8NpSXPMug8LnS+Ry8/Tlbu4WtKzxJfSO9sXVdvdbWprzXqoe8crQ4vX3jMLxtA049qXaaORTbjzud9PY7oCSsPM7QJT2K1iK6t76iu43vMr1ojum8vG+NPJ4E3jsya6A8xDmIvUnu8bvKa6i89Ga3vJdKyjxmwUY8nUciPe00Fzw/V1Q9H74avaeiOTs56S26z5QfvWMwqjxgxO48WiEAvZ3PlTzcRE29gfzAOla1xLzIFhI9fZdDPGNssD09irE8JjyoO4wrOb3525u8Yqg2PLnHyzyGpm28PpoYvawXnr3czEC8Cz20PBhAjbsVY4O9E3j9PP2x57xw4Fe8WhrCvNhuATzQpIY9FBcWvUhm/rsuQqm7o3nCu7wcYj1V+Ag9MqDovFgRGbzidu07HKUKPEbsBjxzTJM86huHve6lZboFBFY8CXARu3m6ubtfPPu8ZTnTPDWEsDxhY4c9Z9EtPJkeq7zHO/O8iU6vPDOwT710EI09qJv7O4eBjDy4ghw9F936vGhpiLyfFEU8jnBoPcX2Qz1V+Ii7JKsLvY+Az7yaLhI9ETPOvGfRrTto4ZQ9hh76PKq7Sb2T5cy8LjvrOk0ujryLk148Mhj1u4cJAD3LoHC7Nn1yu5ZRiLs5cSG88iEIPebyj720HR89wQlTvB6uszuGHno9Ps9gPDeN2bw/38e7O3rKPC32Oz02BeY8crQ4Ox42pzvBkUa8OGE6vKL4jDwzPwE9JKTNPJLV5Tw/30e9DUbdO5aNDjsxW7k8WYLnvEKHiTyxjAK9nQscPS5CKb3vtcy8llEIPYYe+juT5cw8iD7IO4JBcD1VcJU8/LglPHBY5DzuLdk6AS4KPXcpHbzi/mA816oHvNs05rwTUxy7jnBoPYJBcLyZj/k4K3UGvSUswbxZgme9NliRvFa8groltLQ8TJYzPHK0uDz+UAA89sILvdeqhzuKmhw9ECPnPK+oOrzwATo8TvKHvciehbv0KrE83ZA6va0Q4DofL+m83RiuvJRtwDzLKGS8i+aJvIJB8LzTRQq9QGc7vSw5AL1vIxw8AzczPBCymLzPjeE886K9PGcG9rywZXY8c4gZvN4olbu9pNU82SR/PUbshjxszgU7GASHPAp5Or1HIc+869jCPH2Xw7sFfGK8x44eu/XnbLvzGsq7bEYSvPHVGj20Uue8dBANvKxTJD0FV4E76QsgPJuvRzwyoGg8bk+7vDuBiLwFBNY6LjvrO9CdSD3kDki8mNK9u3uOmrwpGTI9yVtBO0zL+zyoI++7d5rrPDM/AT2Mo0W7PpoYu4cJALzDKaE8So2KvI9LB7ysj6q86bh0u56TDz3299O8KIFXO4jGOz3OSLK89TqYPIwrOT3E/YG76L+yu1+Ppjz152w7XcKDPD4iDD3NOMs8rBeevDO3Db2xBI+7hWG+vEO8UTz2wgu8sXVdvWquN7wltLQ89sKLvFmCZ7xo4ZQ8XHaWPGtr8zxjbDC7NxwLPSZ4rry/xKM8xW7QvJHF/jza/508YWMHO9I1Izx8D1C8RrAAvI3vsrr/la87ftzyu7wc4jxkuJ28H74avSDOgTtzTBO9wykhPBK7wTxyPKy8VrVEvdhugbxWvAK8YExivKXVFjypq+I4VryCPH6nKj23crU8Nn3yPOQOyLxRuGw7HKWKPCfEmzy9LEm8llEIvdeqBzyD4Ig8ipocvUYojT1hY4c8w17pO1Ud6jvHjp47HjanO188ezxFifQ7iD5IvOZqHLwhx0O8mvILPKyPqjzLoHA88YJvO8gWkjzuLdk8CTQLPWBTIL1Lhky8OJ1APWx7Wjzmapy70uL3vLH90Dwj55G8sPQnPR7quTyxdV08sPSnvC/DXrzGBqs8B5wwu3J4MjxwWOQ7yyhkvLyrEzyjecK7xObcuwVXgbzATBe7RYl0u+Zj3rxHIc+6eTJGPc3APjwxWzm9VGCuvFAwebuigAA9oz08POvfALyhrJ87gYQ0vaDoJb0rdYa9AifMPKQ2/rxCww+6Lsocu8X2w7yQkLa7il4WPbH90LzOffo66s8ZPej7OD2mVsy7UIOkOqbOWLzS4vc8v4idPIFILjw/38c8XToQvVQkqDy1aYy8g+AIvHCrD7wZyIA8Hy/pPGv6JL2fFEU9cfC+O66YUzy0HZ88SLmpvEr+WLtGKA28hqZtvPMayrzi/mA8J/nju/D6+zsrKZk8/cgMPfFNp7sxH7M8Vz04PA4avjvpCyC9AWoQPE7yBz0gt1w8wQlTvEdtPL0byus7TdviPI7Dk7y3p307/UCZvO1wHbzhubE8lG3Au7nOibp/85c6IhMxPMDUCruyhUQ8aOGUPOSWu7zE5ty7sw04vHFoy7uQCMO8nIOoPPx8nzoDr7+7sYyCPOUeL7zbNOa8zgwsPSXwOjzATBe9xW7QPL/EI72wQJU7ha0rvBCyGL0Fkwc9IEaOvPGZFDsQOgw8xfZDPEI0Xjwq1m28q8uwPEWgmTzr2EK75VP3uyYAojyBhLQ8YWOHPCiB17tgxO68tKUSPerI27zu+BC94UGlvNWKObsc4ZA6g6SCvOrI27y8HGI8YuS8PMD5a7zgMT680vkcvB8v6TywZXa8X0O5vPIK47ya8gu9vjwwvF1vWLz9OVu6il4WPYoL67z9yIy8qoaBvYPJYzybr0c8g1HXPFSsm7zNOEu78dWaOo+ATzz4F6I71yKUPBf0Hz05cSG9HWJGu173y7ztrKO8+UxqPKKAAD0U2w88R6nCPL+Inby4t+S73ETNPE3ioDvY30+869+APZPlzDx5MkY8YlzJPA4aPr3E5ty8sO3pvDIvGjwltDQ8UlBHOxtZHb3difw8MqemO0Zkk7xnWSE8DlZEPFgRGbxb1/28il6WO1HPkbuJg3e9f/MXPJNdWTzsnDy9llEIPbD0pzul1RY9scgIPI3vsjzHO3M7e4fcuIam7bsJ+IQ8QSR3PI7/GT2iadu8E1OcPHcpHT0rXuG8lxWCvHDgVzz0KjG9NUgqvbvXsjtlBAs9WQpbOJPlzLy7myy8ID/QPBNTHLxIMTY9ooCAvH97CzxT2Dq82qzyPHsWjjtkKey7MqemvOCpSj3BkUa8ktXlu88ck7uZpp48IhOxPDIY9bw2ffI8BXxiu2MwKj1XATI8jCu5PM8ck7xszgW7Kk56u6TFLzycg6g7YMRuuymRvrs9v/m7rRDgO3J4sjZ01Aa9Zg20PF5/vzszPwE7ARflvCvtkjuZpp48dc3IvOvYwjtef7+7OJ1AvRsdFz34yzQ9h7bUuz2/eTygnLg8qJt7u+kLIDyQCEM8xObcu35Uf7y8HOI8ZHwXvZw3uzsc2tI8CWlTO1a8Aj3mY147w+2aOp1HojwaDTA8lPUzOzUMpDxjoXg8u9eyPMT9AT3vtUy7lUGhPH7c8jt01Ia6IwzzPM3AvroTB6+61U4zPMoYfbz2b+A8MNPFPGBTILw20J27YBcaO5q2BT3A+es8VOihPClVOD14It88IhMxPEJLA70r7ZK6nleJPN/sjrxN4qC88pLWupOwhLxSUMc8TMt7PKfev7vfsIg9+lzRPABaqTwVY4M8S4bMu7/Eo7xRuOw8Q0RFPdZemrzkWjW6PdYeu1FAYLvAgd+86kBovCMM87x6Qi29uAoQvQsBrrzJ0007Xn+/PJFNcjyejNE7FBeWvOIFn7wNRt28MVu5O+LJmLzWEq07dc1IvCfEmzxse1q8YzAqvVYtUTmN6HQ5nXzqu3sWDj1JQZ08Rpnbu6URnbseNqe8P99HvcugcL3BmIS8QoeJvEqNijxSV4W8e1IUvY13przsJDC8feOwvNNq67yg6KW8JnFwOiNfHjqzlSs8grl8OaGsHzt6yiC9HGkEvQEX5TuGpu27/PQrvJy/LjuL5ok8ErtBPGjhFL1r4/+8+uuCPCMMcz1NapQ87eipPFSsmzyeVwm820sLPTr5lLzbD4W8R208vM/gjDxra/O75mPePPaGBT2tEGC8pL7xOz4iDDzijZI8E3j9O13Cg7xF3B89+BeiPAgkpDx+p6q62w8FuzM/gbyZHqs8JnFwPTq9jjwaSTa9mRdtvIYe+rts82a8/sHOOpuvxzscUt+8+2y4vNrDl7yHCYA8XcIDvRzhkLsEbPu8oVn0Oz3Wnrz07iq8k+VMPAInTL0ztw28Pb95PKfev7q4RpY7w15pOyDOATxse9o7iMa7uxJ/O7xwqw+6owE2vFd5Prt/ZOa800WKvBMA8bwR/oW8RRHovMZ+NzzaO6Q82SR/vOvYQjxSyNO8hy7hu5Wy77xg25O8lsLWu3ftljuhWXQ7a+P/u+qTk7y1Ys68pZkQuqwXnj2mVsy8OSW0PBEzTjyZHqs8uk+/PLUthry8lG68MeOsvPABurq717K8jbOsupiWNzyGNZ87/HyfvJJklzxEzDi9oCQsPZ3PFbuGpm08zxwTPRSIZDucvy68JfA6PPd/RzyCuXw80nGpPCvtEryOcGi7oTSTuzeNWbzMsNc7Y6F4POvfAL1V+Ii8j/jbPNzMQLwZ/Ui8/5UvvCSrC7wXbKw8PiKMvDbQnbzpR6a8KZG+u9/sjjphJ4E7Oa2nu6jupjt82oe8BGx7PMSxlLtwbwk9wNSKvGkmRDz8KXS8yVvBPCAKiDw/38c7dhL4PNzMwLwyp6Y7QXeiul73yzzpR6a83yHXOvRfeTzTRQq9LDkAPVa1xDy/cXg8yhh9PGKotrs9irG8y3uPu5oukjuIPki9k7CEvLgv8Tzw+vu8W2avvD5ekjwbQni8d5rrOs7QpbwEv6Y7rWMLveJ2bTwf+qA5VrXEvGdZobw2BWa85vKPO5EYqjxakk66VrXEvH/zlzvWEi29ovgMvbC4oTymzlg79f6RvBGr2jyivAY9yhj9Oyt1hrmjAba5nL+uvFc9uDwSQ7U8yyhkPFkK2zxK/tg78ZkUudhugTvXqgc9oXCZvHM17jxZ1RK9eCJfOySkzTw3jVm8EwDxvBWYS7ymIQS9QazqOkepwrxO60m9L9oDvbsMezu8lG48NxyLOaLxTjwE9O47x8NmuyplHz2ZHiu8vfcAvZbCVrwmeC69eDkEPGme0Dwq3Su88iEIvPXn7LsX9J+8wQlTPNxEzTwx4yw8wPlrO0I0XrlfQ7k8mWqYu0lBHTzlU/e88iGIvKib+7t4It88Ps/gu6YhhLsD+yw8N+CEPELDD7xGZBO9WpLOPPQqMbw56a08IEYOPY5waLwBn1i6xzvzvOZj3jyRGKo86sjbOg2ZiLsm6fy8kcV+PDcVzTyhcBm9w9Z1PO+1TL091p67enf1u/D6ezy99wA88gpjPCt1hjw+XpK8ngRePCspmbsPKqW7VaVdO7HICLyYlrc8WdUSvB7qOT3mtom8uyOgOc8ck7x5ujk7eHUKPNCdyLzcRE29hvkYuxsdFzzlHq880KQGPQlpUzx2ZSM8sXXdPDBL0rz3Bzs8aSbEPMSxlDzA1Aq9C8WnO4+Az7xIMbY8VCSovDIYdTzmtgm9piGEvO2sI7yWOuO8cODXPOIFn7xh1NU8qrtJvCYAorz9BJO75mqcuxhADT2g6CU81hKtO9O9ljtFGKY8eCLfvB5yrTsRM868qatiu3Kt+joTAPG8JgAivB6usztUlfa8kaCdPGs2Kz3OSLI820uLvN8h17syLxq9ooAAvFzuIj16Qi28f2TmvAGmlrvaw5c8pZmQvJ4E3rxytDg8dEXVvOL+4LzzGsq8yyhkPF8HszwOGj492sMXvdhnw7wVYwO9UDB5PBAj5zxlOVM7GHVVvVGTi7yYlre89m9gPLsM+7yQCMO83+wOPWAXmjvZdyq9HNrSOqgj7zvjhlS9Z1khveUeLz0R/oW7/LglvBQQ2DyxjAK9dL3hvP7BTrs5caG7ZLHfvArxxjyB/EC720sLOy8WirtuEzW9XLKcvOJ27bytJ4W7mraFPHrKoLx0EA28UUDgPOtQz7wcUt87yVvBvFD7MLx/ZGY8vBziPAV84rzmLha8ooCAuUsOQDzr2MK8Hy/pPDFbOT1CNN68y6BwPI6HDT1IMba8UZOLvDIvmj0LAS48aGkIu/LlATwFfGI88Pp7vEURaDsXuJm8tWmMvEnJED2dR6I8GEANvCOU5jxVHeo8rZ8RPA+b87y7I6C7BZMHu8+UHz3wia25IwzzO/GZlDwztw09SXZlPAEXZb3Xz2g7Xn+/ugn4BD3fdIK8XwczO0WgmTsRM048/w08PSrdK72S7Io8y7eVvCFPNzwkpM08YdTVu30fNz2/iJ0869jCO5LVZTws5lQ8PYoxvO3oqTzxTae8RigNPCmRPrzfIdc8KqElvUJLg73slf466pOTPBB2Ejy5P1i9HKWKvIoiEL28bw27D5vzPDBLUrtVHWo8bEYSPOF9Kzwo1IK7\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 20,\n \"total_tokens\": 20\n }\n}\n" + headers: + CF-RAY: + - 92f576351a487df4-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:26:59 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '133' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-cbdb5c968-tkrrp + x-envoy-upstream-service-time: + - '124' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999972' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_5104bbc052358ef7f3e17e8ed2d06987 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Quantum Computing(Topic): Introduction to the principles and + applications of quantum computing."], "model": "text-embedding-3-small", "encoding_format": + "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '174' + content-type: + - application/json + cookie: + - __cf_bm=Jm73zgaX93R7dmdHzthaQLZvS.FDTE7mV9FjnnXOzfk-1744489600-1.0.1.1-PoukpcSnzv7SStgVNleiuwDs4T5hZv9FaVqJkkBq_o1SOXnoQ4d4zSCJ2.fmyc8TLrPx1Ykh1NK4D13sIHXLKj5Oic8deea9HMeiDr3X4y0; + _cfuvid=_e.uFVx98Z8p0BNXXGWGZiyLKJW8yG7vjquHkWxJXnI-1744489600237-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"ZJoevZur3TyThTw8KS5ePBQzcLxzw5W8VDkLvQhsNz13Vqa8fAwPPb/IBT3FvUe8q+mlvUiVHbyuRBo8ZKFbvMDr0LqAwuo8iOFOPZzALj3jFvM7k3Dru+sgkzvJQlG5JHG4vEB2Ob2jwwQ9pzqHPSHsLj2wgwC9Gxo4PcJUzLw/TKQ85lyju+GmOj0NKV08QX2Du4jhTjyeDRy9HC8JPaFaCb0UM3C9Ngrou5JUXT2FcRa9wj/7uh6DM72SPxm95CQHvT0GAT2fGyM9ZyZlO8EOKbzhu4u85UAVvbGtlTwIV2a8EG+NPP7cmjxNUsM8PinMOzN+obt/ply8IzmcPCj9/rw7qwy9zvg5uo6siDy1f3+8ZKHbPEZPbTzlR9I6VFzWPGXSOj1FM988xb1HvOeUP713h3g8cGFXPNKZUTwqSmw8f4ORvBZdEj3tZja9LJfZvCNc5zz+6iG9wRywvKiAKr3EqPa7cEyTPCNHIz2oh2c8F5zrPK51bDzDTQ+977rgPKF9VD1bQx486gR4O/tzH72x3ue8XbPWO4x7qTsqSuw9d1amu+eUP71NUkO8ueE9vWlzUjyMbSK9jrqPO1jaIrzw6788BectvLnaAL0E0ty7fCFTvbMPx7wpCxO8CYhFvcDyGrgsghW96JsJPTg0irxOil+9zc4kPZgm1Lw2Cmi8AU1TPboZWj0GH8o8MU1CO6TRi7uUjAY9zzBWvUd5Dz2HxUA8C9zvuzg0Cr2VvVg9OqRCvfkmMj2wkQc9kACzPCNcZ7x68PO8MoXePOL6ZD0cUtS7oGHGvArAYb0Zxg28qaN1PH094TzrNVe8MVR/vOQrRD098a+84cJIvf7OkzykAt45dk/cvP7j17wXnOs8/xv0vBZkz7wXnOs8yS0NvWleDr2ioKy8ACoIvbMPxzwqNSi8KkMvPdvUQ7peuqA8w3BavS/5l7qpnLi8bfjbOqdrWbzKczA8RmS+u9z3mzzMsha9DPHAuipK7Dwts+e7IiTLPItDDTugYcY8yleiPEw2NT3RYTU9kACzO/yrOz1/ply8Ug9pPKTtmb1JzTk91jppPA4+rjxwYdc8kAAzPddPurvue4c9eIA7vdhki70ljUa932CXuzhQmLxsuYK7JFWquygSUL1cgne9XZ6SOxQCnjtUVZm8iegYPXq/IbsbIfU7yTuUu0rpRz26IKQ8izWGPFtDHr2P6+G7xIUrPUK1H734CqQ706AbveoZSTxX4d+8cq7EvO+64DvG0hg9C7kkvZJNIL2aev68DQ3PPICtpjzcBSO9VY01PDzc3jxiTbG7PRR7vEsMoDzb2408VqnDu06DIrs17tk8M4wovMp6bTuQ8qs6C7kkveL65Du8X4o8x+4mPdKEjTzYZIu933VbvaUJKDxzylK9C7mkvIMIGz19UjK8JqnUPPIqprznjYK8mBGQPEwaJz3O/3a8dTPOu57xDb3WOum80pnRvH+RGDvav/K8wRwwPfpJCjsre8s7EIubOyaUED1Ppu268j/qPFyChLouzwK7IeyuPGW2LL06iDQ9S/ARPZIxEr1R7B28yleiPP8Ut7sAOA89/tyaON5ZzbrJHwY84a2EOunhrLxds1Y8gdc7vZbuN7yac0E74aa6u7Cfjrzw5IK8a8d8vRHKdLxLIeS7MnAaPcI/+zxvRUm9x+4mvJSaDb1nEaE9ULQBvaiH57zc9xs9SJWdPJgm1Dw+Ig87ZL3pvPWToTycwK68ACqIPLVjcTx+ZwO9iRnrPIs1hjyq1FQ7GenYvFHsnb0ftBK7R10BvbZxhT11EIO9CYhFvNOgG72SVN28C9UyOwcYDTwdbuK777pgPeipELwqQy88nzBnPV2ekjzXTzq9ii48vfbE8zyhdhe9AnArPaF2l7wAOI88FU9+vMSo9rxQtIE8e+k2vcEOKbzHEXI8gd74PKBFOD08+Gy8XrogvWqPYL2DCBs7gyQpvNFhtTtEF1E8uhKdPEQCDb3zW/g8+2UYvP7cmrvXTzq8Co8PvMI/ez2DCBs9VZTyOCNc5zvqBIW7V+HfO7oZ2jzhwki7ao9gvFV45DvCOL47MmnQu28+jLvH9eO7JFWqPUiHFr2SVN0778EqPGSh2zvT0e08K1iAvMNpHTxCwyY7djoYPVVjIL337pW76hlJvRnUFD0F5608EHZKuwXnrbx8DI87eIcFvX91Cj1oQnO8wQCivEsMIL2FcZa8qaOCPL17mDxXzBs9D2F5PYxtIj3RYTW9GuKbuS8c47zAB988M5ovPVtRJb2YERA9NcuOvWSMFzsg0KC8aXPSvLMrVT1f5DU8pQmovKK18LxdkIs84JFpPMpXIjyxrRW92rg1PGzczTzrEgy9CFdmvHsFxTzA5JM8pN8SvenTJT14gDu97p7SPM3jaLt2Ohg96gT4vJEji7wErxG9CHN0PD0U+7wAMcU8cFqaO+2CxLyAwuo8+Ul9vS8cYz1J1HY8OqRCPTXLDj1kods89HcTvawhwrw9FPs8k3BrPP3HyTyabIS9Q980u6wFNDsZuIY9ACoIPfEHTjv6Xk48W1+sPCEIvbxK1IM61hcePca2Cr2aeos8svO4vAXu6jz7luo8wNaMPGSoJb2EXMW8TmcUPRsauLv1k6E7JsXiu12ekrkVLLM7oVqJPFV45DuI4c48ndw8vNFhtTxwaCE8NLa9O4MkqTtiab88j+QkPQOTgzwycJo8xb1HPcgmQ735SX28Gc1KvGSMl7wVT348diwRvK+RejpWqcM8EJLYvNTmvjwRynS8BgM8PF8ARLwNBpI75lyjO8NwWr2bpCC9ldlmPCa+pb3P/4M8e+k2vAvcb7zi5SC8mCZUPAKhfbxBksc73OmUPLG7HLyYHxe9+5bqO05uUbxQuz49+SayPAOhirwT5o88RAKNPE6KX7xgB468GvAiPWYK1zzdEyo8ueE9PYjhTjzV3wE9uhnau1kZfLu56Ac8yleiu4He+LwXnOu7xIxovEic2rtdkIu7SbErPQhQKbuKEi69IPNrvYRANzwvHOM7F5zrO9vNBrsT+1M8eIcFPdOuIrp/is6729RDvKFokDs2A6u7wSNtPavwYju2cQW90WjyvKhyIz107aq8R12BPNFhNbtXxVE9fAyPPLaU0DrO+Lm71d8BvHYskTsycBq8zdyrvFapQzyLSsq8a6tuPIi+g7yCD1g98QdOPIepsjw5j/G69GkMO6whQrxSCKw7cEwTvbebGj3hwsg9QZLHOr/W/7wUM3A8m5YZO0ZIsLuUoco8FAKevEPftDw+Kcy6XuvyPDz47DvV7Yi8P2FovDzHmjxPwnu8dTNOPQAcgTwu5MY7Dj4uvB6DMzspLt68MU3CPLMPxzxY2qI7w00PvH5ng7sn4fA8cFqau5SajbwRmaI9ZL3puaBhRjzdIbE6ZwMaun51/TwRmSI9Ne7ZPLxmx7xEF1E6P0ykvJp6/rxvRck8/cdJvF2Qiz1MPfK8WkpbO99unrwVLLO8XZCLvK9uL7yNlze67YJEvdFocr0xRoU7r4q9uwTSXLrlY+A83kSJPI/rYTzFoTk7282GPDlz47wzfiE8uzXoPJEcQby6BJY7jZc3vE+RKbz32US9/xQ3O7n2jjye/5S7jIJmvEicWjvGtoq6/Ku7vDhCEb2RFQS9m49Pui7kxjxX4d+86v06OrCDAD1pUAe8FBAlveeUP7xiaT+95U4cPCjvhLqitfC86gQFvbRH47x03yM75n/uvB6m/rwiAYC8m6tdvF2eEr0n4XC7Gxo4PVyCBDxpQgA9yR8GvBPmj7z7ely76v26vDlspjvc6ZQ8o66zvFkSPzwoEtC7ZKHbvIaNpDxPkam6cEyTvMEj7bw25xy9RBfRu1yC9zwqNSi8ho2kPBoFZzxInFq8W2ZpPEK1n7wDmsA8Lwefuwc7WL1MNjU7vZ7jPHBaGr3IJsM7klTdO8So9jxrliq8ZxGhO9dW9zwRmaK8fVlvundrarzQRae8xsQRvOoEhTtD0a07xKj2vLtKOT1R0A+85n9uPEUQFLxJzTm8sIOAvC2zZ72nOoc8hrDvvOw8IT2W7re8KBLQPKUJqDo3O0c6ndy8O9BFp7yQ8is9wRwwPTOMKL3+41c8Xutyu8a2CrxcgoS7cH1lOnKuxLwo7wQ9E9gIPZgfF71K4gq8lb3YvL6ztDv7ZZi8Ymm/PNApGbsljca8yUkbvNKSFDyKLjy8tEdjvOeb/DyW7re8GgVnuz9F2jytNhO9PfEvvawM8TygRbg8RkiwO59MdTugYUY8+S1vOfDrvzzq/Tq9UyuEPHq/Ib0PWrw8WRI/PZuIkjzqBAW9uLeoPDc7R70XnGs8Izmcu8zH2rrrEgy8e+m2u9O1Xz0F2aa8OFfVvCkuXrx7BcU8vrO0uhQCHryihJ48ZL1pvFj2MLx3a2o9rRoFPEU6qbyJ/Vw6K3vLPGlXxDsegzO8UeydvPf1Ur0jKxU8K1+9vHBoIT3N4+i8fT3hPEshZDxqehy9v8/CuR+fQbwJc4G8QX0DvZgmVLtJzTk9cZK2vD0UezzJQlG8HUsXPNUCzbyqvxA709HtPBQeLL0/Yei7vGbHvIV407zuiQ69izUGPWlXRDwDk4M8tnEFvIawb7xnAxo881v4PEPftDzToBu9O6uMOzXZlTyUjIa86xIMu3QCb7xWqUM89/XSvHKnhzwgwhk8eaOTuroSHTxhMaM8ii48PHKZAL3RYTU9kTjPPBVPfjwaBee8a8f8PNvUwzr6V5G7EaepvN0obrzSdoY8YTGju5EcwTujrjM8p1YVvUdriLzhrYS7er+hO/RwyTwKwOE7P1qrvDOh7LzTvCm9LxzjvAS9mDy52gA9u1F2uxw2Rr3osM08C9WyvKPDhLzJLY08mUmsvMDyGr1ZEr+8ng2cvCR4db0sl1k76LBNPbxfCryac0G8Q9EtvGcfqDsyadC84HwlPRQz8DzEd6S8oEW4vPkt7zwcPZC89IxXu7/IBTtGa/s7+l7OOusumjsfpos8ufYOvMpe37uGm6u8QX0Du5SaDb37lmo9lIyGPIo1eTzN3Cs9VXhkvd42grzdKG481d8BPSa+pTxSK/c80EUnu3iHhbupnLg7DQYSPXwhU7xhP6q8O7mTvHwoHbyLURS9FDNwPKvw4jwu5MY7HopwOyyXWT2lCag7XIL3O7aU0DuzD8e8jGbYPPRbhbwmopc84teZvLew3jvYchI6guyMPOCR6Tq3jRM8m6vdO6PKQb1MNrU8e/6HPAdCIrt8KB27OXPjux6KcLxhOGA7rT3QvL1tkbs9DT68vYLVvGJpP7u5/cs8wlTMvP3ADLyThbw7F4BduRLKgbxaLs28nvENusEj7bzwz7E7opIlPA0NzzvtbYA8uMzsO0GLirzZh1Y8A6EKPI/IlrysKH88zzDWuhPYiLxaLk29IgGAPK0ojLzXTzo8FkGEPaBFOLq+unE7uy6ruYLehbvAB188jZ70PBwvibx03yO9MmKTPMkfhrxJ1Pa8uf3LPFMkurw+KUw8SLjoPHm41zyfGyO8es2ou9J9Qzw1yw49rnXsu8fuJjtY6Km6y48+vdOuorw0vXo8NyaDPCRVKjy5/cu7Q9+0vHBMkzw6q388JrCeujhXVT2Auy07xtKYundr6rvJLQ29nvGNvDurjDy+pa07gJ+fvCDep7whCL285BaAPIMWIj14gLs8FkGEu+i3F7xFEBS8ndy8u0UQlDyP62G8wPKau5zjebwIbDc6OXNjPffulbp9WW+8sa0VvVQ5izyOnoE8W1+svNXfATxuMHg8r4q9Ol8AxDl7/ge6DSldvUsh5Lw17tk8sIMAPSIBgLycx+u7pQmoPCtmhzuUmg09hEf0O46zRbwHQqK79aEovYRHdLyj0f67tnjCvMktDTxTQMi71gmXPHZPXLxMGqc8TmcUudUCzbstnqM8UdCPPCNA2bsIV2Y7n0x1O0rUgzyzD8e8ByYUuniHhbxwfWW8J8ysPGzVkLzw6z+8GLG8vKq/kDwXeaC6rmAoPa5EGjwwMbS8HC8JvTz47DyYQuI8sIMAvQTS3Lul+yA9GLG8PJAAM7wM8cA8AnArPAKh/bwEr5E76yATO8NbFj0T9BY8jHspvJ7xDT0Kqx09fBoWPTzc3rxMGqe8YAcOvfuW6jsKnZa88QARPDzc3ry3jZM8gyQpvSDCmbvx8ok7k2kuPJW9WDo/RVo7AVQdvBwhArxBiwq9rlnevEicWrzFvUe6udoAPYi+Az0PYYa88QCRO3Ue/Tsg1908A5MDPA9avLk7qww931KQOyIky7zHEfK8Rmv7vFaihjyqv5C7Kmb6OtYeW7rBI+28hpRhPEB2OTu3jRO9Oog0vCfas7zsUWU8+S3vu+s1V7xK4oo8O6uMvGSh2zoT+1M9TVLDuk1ZDT3FoTk9T5+wOx+YBL2vkfo8mB8XvSNHIz3SdoY7+BFhu0sMoLy7Ufa8HW7iO/uBpjy1Y3E7LuTGPLtR9jvzW3g8cZI2PM7/9jzFvce8QqcYPItKyjsVSEG7mC2ePPgYqzzICrW7+BFhPLepoTuUocq6GLG8vJAH8Lw3O0c8KPbBuxPmD7zmf248UfPaPA9h+Ty/z8K6SulHvPDrP71D0a28LIIVPadPSzx4h4W7H5gEPFWNNTzToJs8cXaousbZVTtXzJu5wOvQvN5ECTzozFu8hEC3vMpzMDypowI7+3rcvN9SkDxf5LW6anocvd9SELzxI9y5eIcFvSMrlbu/z8K8XsinPMEjbbwXgF28DjCnu9FhtTwM+H08YVRuPK0aBb1dnpI8VXGnPPHyibwqSuw81OY+OzvAUD2z+oI8H7vPPHmjkzyYLR4832AXO2NwibwcL4k7PiIPvPo7g7xnJmW8nykqO23427xVeOQ7u1F2vEijJL0UF+I8PhQIPZShSj1IlR28NztHPE6DIr1E+8I67EqoPFC0Abgo/X48P1oru35uQL1icPy7ldlmPFMkurnrIBO6tnhCvDN+obwycBq9Rmt7POZ4MTsQdso6XuvyPM74uTwF2Sa97YLEvG4w+DtjfpC89/XSO4i+A706iLS8KBLQOsgmQzu0R+O85UdSPIHeeLvVAk07aVAHPPRbBbyr2548xb3HuwhX5rq6BBa8y4++PF8AxLzPFEi7ltIpOGcmZbw6q/88LJCcPPDy/LwxRgU8IPNrvD0GATwGH8o8R4DMPFNAyDxZCwK95WPgPKTfkrwiAQC7SwygPK5SIT0fmAS9f6ZcPM8w1jusBbQ8pNGLvI/kpLulFy+6yS0Nu35ngztpQoA6MoVePKPKwbwIV+Y7uy6rvMDymry0Mp88Ymk/vIRcxTvePT88kj8ZPavpJTwHO1g8p2vZu7xmx7uXCka99+COPMI/+ztkvWm8RkiwOzXZFT1rpLE8Y34QPWzVED2d3Dy94K33O5b1dDyLNQY8DQaSPLnoh7wJiMU7wSNtPIVxFjwa4hu99IzXPDN+Ibubq908Gc1KvCyXWbzcDOC7ueE9PbjMbLshCL08dR79vHUe/TzEjOi8oEW4u5lecLyqzRe7An4yvRixvDuoh+e8hXhTuuL6ZDr0d5M7ueiHvIV40zunT0u8cZK2vAvHq7xzylK8ULu+O1WNtTwKqx28NcsOPFHzWjyX9YE8AnCrPEnUdj1bZuk6a8f8vNOgmzthOGC7aVAHvZb1dDx78IC79r02us3cq7wJcwG7rSgMOcWog7xPpu07K1gAu9Tmvrvb8NG7klRdPItDjbsFCvk8SLhoukUsojsEyx+7QrUfO6UXLzvav3K7w1sWPZ3cPLxpUIc8oX3UPErUgztBmRE9m4/PuGlejj29bZE7cEyTvCHsrju+unE8swgKvZOFvDxpQoC8A6EKPZ8pKr37etw8LHQOPIMIG7y46Ho81gmXOxoF5zsEy5+6zMfavG9FSTzEdyS9EIsbPYjhTj0u3Yk8cH1lPUUeG72+szQ699nEPOLXGTuJ9h+8dk9cPTqkQjx7/ge8EacpPYkEJzxfAMQ8SJzaO1HsnTo7wFA7ynrtutX7j7wg82s8FSwzPAXnrbs7wFC9uMxsu2ExozquYCg8E/SWuxQerLsXlS48hpurvP8b9LwBaeG8gJ+fPBnpWLmzK9W8HW7iPOVj4LwpCxM9K1gAOr66cbzdKO68/xS3vIRcRT3i3ta8\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 16,\n \"total_tokens\": 16\n }\n}\n" + headers: + CF-RAY: + - 92f576398d1d7df4-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:00 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '48' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-54db47bfc6-lckj7 + x-envoy-upstream-service-time: + - '35' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999977' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_cf296ef00ca28fa7666df280e1825686 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Sustainable Energy Technologies(Topic): Technologies that contribute + to sustainable energy solutions."], "model": "text-embedding-3-small", "encoding_format": + "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '180' + content-type: + - application/json + cookie: + - __cf_bm=Jm73zgaX93R7dmdHzthaQLZvS.FDTE7mV9FjnnXOzfk-1744489600-1.0.1.1-PoukpcSnzv7SStgVNleiuwDs4T5hZv9FaVqJkkBq_o1SOXnoQ4d4zSCJ2.fmyc8TLrPx1Ykh1NK4D13sIHXLKj5Oic8deea9HMeiDr3X4y0; + _cfuvid=_e.uFVx98Z8p0BNXXGWGZiyLKJW8yG7vjquHkWxJXnI-1744489600237-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 15,\n \"total_tokens\": 15\n }\n}\n" + headers: + CF-RAY: + - 92f5763e08747df4-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:00 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '81' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-54db47bfc6-lrh5m + x-envoy-upstream-service-time: + - '48' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999974' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_af41b415673a99d60da19b2d4c600738 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["5G Technology(Topic): Explanation of 5G technology and its + implications for various sectors."], "model": "text-embedding-3-small", "encoding_format": + "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '171' + content-type: + - application/json + cookie: + - __cf_bm=Jm73zgaX93R7dmdHzthaQLZvS.FDTE7mV9FjnnXOzfk-1744489600-1.0.1.1-PoukpcSnzv7SStgVNleiuwDs4T5hZv9FaVqJkkBq_o1SOXnoQ4d4zSCJ2.fmyc8TLrPx1Ykh1NK4D13sIHXLKj5Oic8deea9HMeiDr3X4y0; + _cfuvid=_e.uFVx98Z8p0BNXXGWGZiyLKJW8yG7vjquHkWxJXnI-1744489600237-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 19,\n \"total_tokens\": 19\n }\n}\n" + headers: + CF-RAY: + - 92f576409a3d7df4-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:27:00 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '83' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-8486cc455c-9tl6g + x-envoy-upstream-service-time: + - '64' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999977' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_2747968746840775dd660a77dacd834a + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/memory/external/cassettes/test_crew_external_memory_search.yaml b/tests/cassettes/test_crew_external_memory_search.yaml similarity index 100% rename from tests/memory/external/cassettes/test_crew_external_memory_search.yaml rename to tests/cassettes/test_crew_external_memory_search.yaml diff --git a/tests/cassettes/test_handle_streaming_tool_calls.yaml b/tests/cassettes/test_handle_streaming_tool_calls.yaml new file mode 100644 index 000000000..20c69b053 --- /dev/null +++ b/tests/cassettes/test_handle_streaming_tool_calls.yaml @@ -0,0 +1,133 @@ +interactions: +- request: + body: '{"messages": [{"role": "user", "content": "What is the weather in New York?"}], + "model": "gpt-4o", "stop": [], "stream": true, "stream_options": {"include_usage": + true}, "tools": [{"type": "function", "function": {"name": "get_weather", "description": + "Get the current weather in a given location", "parameters": {"type": "object", + "properties": {"location": {"type": "string", "description": "The city and state, + e.g. San Francisco, CA"}}, "required": ["location"]}}}]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '470' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.74.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.74.0 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.11.12 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + body: + string: 'data: {"id":"chatcmpl-BMyImYKF6jsJsQzWvhNfNb4gAIRVc","object":"chat.completion.chunk","created":1744814716,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"role":"assistant","content":null,"tool_calls":[{"index":0,"id":"call_bCEixqN8Y40SUyius8ZfVErH","type":"function","function":{"name":"get_weather","arguments":""}}],"refusal":null},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMyImYKF6jsJsQzWvhNfNb4gAIRVc","object":"chat.completion.chunk","created":1744814716,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\""}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMyImYKF6jsJsQzWvhNfNb4gAIRVc","object":"chat.completion.chunk","created":1744814716,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"location"}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMyImYKF6jsJsQzWvhNfNb4gAIRVc","object":"chat.completion.chunk","created":1744814716,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"\":\""}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMyImYKF6jsJsQzWvhNfNb4gAIRVc","object":"chat.completion.chunk","created":1744814716,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"New"}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMyImYKF6jsJsQzWvhNfNb4gAIRVc","object":"chat.completion.chunk","created":1744814716,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":" + York"}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMyImYKF6jsJsQzWvhNfNb4gAIRVc","object":"chat.completion.chunk","created":1744814716,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":","}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMyImYKF6jsJsQzWvhNfNb4gAIRVc","object":"chat.completion.chunk","created":1744814716,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":" + NY"}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMyImYKF6jsJsQzWvhNfNb4gAIRVc","object":"chat.completion.chunk","created":1744814716,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"\"}"}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMyImYKF6jsJsQzWvhNfNb4gAIRVc","object":"chat.completion.chunk","created":1744814716,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"tool_calls"}],"usage":null} + + + data: {"id":"chatcmpl-BMyImYKF6jsJsQzWvhNfNb4gAIRVc","object":"chat.completion.chunk","created":1744814716,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[],"usage":{"prompt_tokens":68,"completion_tokens":18,"total_tokens":86,"prompt_tokens_details":{"cached_tokens":0,"audio_tokens":0},"completion_tokens_details":{"reasoning_tokens":0,"audio_tokens":0,"accepted_prediction_tokens":0,"rejected_prediction_tokens":0}}} + + + data: [DONE] + + + ' + headers: + CF-RAY: + - 93147723ecc1f237-GRU + Connection: + - keep-alive + Content-Type: + - text/event-stream; charset=utf-8 + Date: + - Wed, 16 Apr 2025 14:45:16 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '620' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '30000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '29999989' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_0a08d5f042ef769aeb2c941e398f65f4 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_handle_streaming_tool_calls_no_available_functions.yaml b/tests/cassettes/test_handle_streaming_tool_calls_no_available_functions.yaml new file mode 100644 index 000000000..ef780dee8 --- /dev/null +++ b/tests/cassettes/test_handle_streaming_tool_calls_no_available_functions.yaml @@ -0,0 +1,133 @@ +interactions: +- request: + body: '{"messages": [{"role": "user", "content": "What is the weather in New York?"}], + "model": "gpt-4o", "stop": [], "stream": true, "stream_options": {"include_usage": + true}, "tools": [{"type": "function", "function": {"name": "get_weather", "description": + "Get the current weather in a given location", "parameters": {"type": "object", + "properties": {"location": {"type": "string", "description": "The city and state, + e.g. San Francisco, CA"}}, "required": ["location"]}}}]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '470' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.74.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.74.0 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.11.12 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + body: + string: 'data: {"id":"chatcmpl-BMy4cOLWqB5n5X1Zog3uV9Y7Lrkwp","object":"chat.completion.chunk","created":1744813838,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"role":"assistant","content":null,"tool_calls":[{"index":0,"id":"call_ccog5nyDCLYpoWzksuCkGEqY","type":"function","function":{"name":"get_weather","arguments":""}}],"refusal":null},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4cOLWqB5n5X1Zog3uV9Y7Lrkwp","object":"chat.completion.chunk","created":1744813838,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\""}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4cOLWqB5n5X1Zog3uV9Y7Lrkwp","object":"chat.completion.chunk","created":1744813838,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"location"}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4cOLWqB5n5X1Zog3uV9Y7Lrkwp","object":"chat.completion.chunk","created":1744813838,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"\":\""}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4cOLWqB5n5X1Zog3uV9Y7Lrkwp","object":"chat.completion.chunk","created":1744813838,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"New"}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4cOLWqB5n5X1Zog3uV9Y7Lrkwp","object":"chat.completion.chunk","created":1744813838,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":" + York"}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4cOLWqB5n5X1Zog3uV9Y7Lrkwp","object":"chat.completion.chunk","created":1744813838,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":","}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4cOLWqB5n5X1Zog3uV9Y7Lrkwp","object":"chat.completion.chunk","created":1744813838,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":" + NY"}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4cOLWqB5n5X1Zog3uV9Y7Lrkwp","object":"chat.completion.chunk","created":1744813838,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"\"}"}}]},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4cOLWqB5n5X1Zog3uV9Y7Lrkwp","object":"chat.completion.chunk","created":1744813838,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"tool_calls"}],"usage":null} + + + data: {"id":"chatcmpl-BMy4cOLWqB5n5X1Zog3uV9Y7Lrkwp","object":"chat.completion.chunk","created":1744813838,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[],"usage":{"prompt_tokens":68,"completion_tokens":18,"total_tokens":86,"prompt_tokens_details":{"cached_tokens":0,"audio_tokens":0},"completion_tokens_details":{"reasoning_tokens":0,"audio_tokens":0,"accepted_prediction_tokens":0,"rejected_prediction_tokens":0}}} + + + data: [DONE] + + + ' + headers: + CF-RAY: + - 931461bbddc27df9-GRU + Connection: + - keep-alive + Content-Type: + - text/event-stream; charset=utf-8 + Date: + - Wed, 16 Apr 2025 14:30:39 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '445' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '30000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '29999989' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_1bb5862de2891623d44c012aba597c5e + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_handle_streaming_tool_calls_no_tools.yaml b/tests/cassettes/test_handle_streaming_tool_calls_no_tools.yaml new file mode 100644 index 000000000..e9a76d139 --- /dev/null +++ b/tests/cassettes/test_handle_streaming_tool_calls_no_tools.yaml @@ -0,0 +1,279 @@ +interactions: +- request: + body: '{"messages": [{"role": "user", "content": "What is the weather in New York?"}], + "model": "gpt-4o", "stop": [], "stream": true, "stream_options": {"include_usage": + true}}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '169' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.74.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.74.0 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.11.12 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + body: + string: 'data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"role":"assistant","content":"","refusal":null},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":"I''m"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + unable"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + to"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + provide"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + real"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":"-time"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + information"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + or"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + current"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + weather"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + updates"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":"."},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + For"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + the"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + latest"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + weather"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + information"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + in"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + New"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + York"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":","},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + I"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + recommend"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + checking"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + a"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + reliable"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + weather"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + website"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + or"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + app"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":","},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + such"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + as"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + the"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + National"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + Weather"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + Service"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":","},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + Weather"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":".com"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":","},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + or"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + a"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + similar"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":" + service"},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{"content":"."},"logprobs":null,"finish_reason":null}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}],"usage":null} + + + data: {"id":"chatcmpl-BMy4dVQFM7KUrmflCVk4i454PXCga","object":"chat.completion.chunk","created":1744813839,"model":"gpt-4o-2024-08-06","service_tier":"default","system_fingerprint":"fp_22890b9c0a","choices":[],"usage":{"prompt_tokens":15,"completion_tokens":47,"total_tokens":62,"prompt_tokens_details":{"cached_tokens":0,"audio_tokens":0},"completion_tokens_details":{"reasoning_tokens":0,"audio_tokens":0,"accepted_prediction_tokens":0,"rejected_prediction_tokens":0}}} + + + data: [DONE] + + + ' + headers: + CF-RAY: + - 931461c25bb47df9-GRU + Connection: + - keep-alive + Content-Type: + - text/event-stream; charset=utf-8 + Date: + - Wed, 16 Apr 2025 14:30:40 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '298' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '30000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '29999989' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_89971fd68e5a59c9fa50e04106228b0a + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_long_term_memory_with_memory_flag.yaml b/tests/cassettes/test_long_term_memory_with_memory_flag.yaml new file mode 100644 index 000000000..acc1d38c0 --- /dev/null +++ b/tests/cassettes/test_long_term_memory_with_memory_flag.yaml @@ -0,0 +1,1035 @@ +interactions: +- request: + body: '{"input": ["Research a topic to teach a kid aged 6 about math."], "model": + "text-embedding-3-small", "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '129' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 13,\n \"total_tokens\": 13\n }\n}\n" + headers: + CF-RAY: + - 92f5c1e05c337dfd-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 21:18:38 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=EmHz1EYky7JW_ELsgMXI7amRZ4ggf4.6l8BV8FXmAW4-1744492718-1.0.1.1-5huIPLAuZz_NdAPPRxCBl_U6lUxrPRTG4ahM4_M8foKARhQ42CjSvaG96yLvaWGYy6oi27G7S_vkUA11fwrlfvGOyDE_rcr5z1jKKR4ty5M; + path=/; expires=Sat, 12-Apr-25 21:48:38 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=W5j_MoZsp4OTTk_dhG3Vc74tetKESl9eXL85k6nIfqY-1744492718564-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '84' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-79686db8dc-x9rxq + x-envoy-upstream-service-time: + - '51' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999987' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_caff05a3dfec5fa7b4fa07c1845a3442 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Research a topic to teach a kid aged 6 about math."], "model": + "text-embedding-3-small", "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '129' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 13,\n \"total_tokens\": 13\n }\n}\n" + headers: + CF-RAY: + - 92f5c1e38df27e15-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 21:18:39 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=nWdwrALuDHGwSXnqBZrJBXSSPHnEseaG_PBL5PAWfl8-1744492719-1.0.1.1-Z3sLE_wR.gk2PzN7zUKeFWF5QvfCyVb1ad25WiOcZNNiKSwT8aw.rupvl1GC.LvaaIHb1BMZH0esXrXO7aWCz.C66bT3ilMVbLgjSJhc.bA; + path=/; expires=Sat, 12-Apr-25 21:48:39 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=I1qVn4HwObmpZbHCIfihkYYxjalVXJj8SvhRNmXBdMA-1744492719162-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '148' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-7d86d58f9c-7j5fx + x-envoy-upstream-service-time: + - '97' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999987' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_b5655848edcaab43cc58f35fd9e8791c + http_version: HTTP/1.1 + status_code: 200 +- request: + body: !!binary | + CuAMCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkStwwKEgoQY3Jld2FpLnRl + bGVtZXRyeRKdCAoQ0ET5xesb6Q0K4SQYYxCwexIICDZWwq2loxEqDENyZXcgQ3JlYXRlZDABOSCZ + xl/irjUYQcB4zl/irjUYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGgoOcHl0aG9uX3Zl + cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIGM5N2I1ZmViNWQxYjY2YmI1OTAwNmFhYTAx + YTI5Y2Q2SjEKB2NyZXdfaWQSJgokZjEyYTNlNTctNTkwOC00M2MzLWJlMDgtOGVkMWQ5MGI1ZjI3 + ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAUoaChRjcmV3 + X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3 + X2ZpbmdlcnByaW50EiYKJGY4NjdhM2I5LWNiZDItNGFkMS1iMDA1LTUxNGUyMTlmNThmN0o7Chtj + cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xMlQxODoxODozNy44NDYzNDZK + 0QIKC2NyZXdfYWdlbnRzEsECCr4CW3sia2V5IjogIjA3ZDk5YjYzMDQxMWQzNWZkOTA0N2E1MzJk + NTNkZGE3IiwgImlkIjogIjUxNWY1ZmViLWE0YWUtNDEzOS1hNWVjLWU5Y2M5OWZiOGU0MiIsICJy + b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiBmYWxzZSwgIm1heF9pdGVyIjogMjUsICJt + YXhfcnBtIjogbnVsbCwgImZ1bmN0aW9uX2NhbGxpbmdfbGxtIjogIiIsICJsbG0iOiAiZ3B0LTRv + LW1pbmkiLCAiZGVsZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRp + b24/IjogZmFsc2UsICJtYXhfcmV0cnlfbGltaXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX1dSv8B + CgpjcmV3X3Rhc2tzEvABCu0BW3sia2V5IjogIjYzOTk2NTE3ZjNmM2YxYzk0ZDZiYjYxN2FhMGIx + YzRmIiwgImlkIjogIjg0MWQwYmYzLTJiMjYtNDQyOS1iMmI3LTZjNGU5NmMwMjcyNiIsICJhc3lu + Y19leGVjdXRpb24/IjogZmFsc2UsICJodW1hbl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUi + OiAiUmVzZWFyY2hlciIsICJhZ2VudF9rZXkiOiAiMDdkOTliNjMwNDExZDM1ZmQ5MDQ3YTUzMmQ1 + M2RkYTciLCAidG9vbHNfbmFtZXMiOiBbXX1degIYAYUBAAEAABKABAoQM7sVqAHRf3ggmz4DVDpp + TBIITf1hDjTQpicqDFRhc2sgQ3JlYXRlZDABOXjF2F/irjUYQYAX2V/irjUYSi4KCGNyZXdfa2V5 + EiIKIGM5N2I1ZmViNWQxYjY2YmI1OTAwNmFhYTAxYTI5Y2Q2SjEKB2NyZXdfaWQSJgokZjEyYTNl + NTctNTkwOC00M2MzLWJlMDgtOGVkMWQ5MGI1ZjI3Si4KCHRhc2tfa2V5EiIKIDYzOTk2NTE3ZjNm + M2YxYzk0ZDZiYjYxN2FhMGIxYzRmSjEKB3Rhc2tfaWQSJgokODQxZDBiZjMtMmIyNi00NDI5LWIy + YjctNmM0ZTk2YzAyNzI2SjoKEGNyZXdfZmluZ2VycHJpbnQSJgokZjg2N2EzYjktY2JkMi00YWQx + LWIwMDUtNTE0ZTIxOWY1OGY3SjoKEHRhc2tfZmluZ2VycHJpbnQSJgokY2M2YzFmMjctYWRiMy00 + YjJiLTg0OTEtNjE4OTFhY2RiODQ4SjsKG3Rhc2tfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoy + MDI1LTA0LTEyVDE4OjE4OjM3Ljg0NTQwNko7ChFhZ2VudF9maW5nZXJwcmludBImCiRlZWQ1MDZj + YS1lMWI1LTQzMWItOWIyNS00YWIxYzU2ZjhiYjF6AhgBhQEAAQAA + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '1635' + Content-Type: + - application/x-protobuf + User-Agent: + - OTel-OTLP-Exporter-Python/1.31.1 + 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: + - Sat, 12 Apr 2025 21:18:42 GMT + status: + code: 200 + message: OK +- request: + body: '{"messages": [{"role": "system", "content": "You are Researcher. You''re + an expert in research and you love to learn new things.\nYour personal goal + is: You research about math.\nTo give my best complete final answer to the task + respond using 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 complete + as possible, it must be outcome described.\n\nI MUST use these formats, my job + depends on it!"}, {"role": "user", "content": "\nCurrent Task: Research a topic + to teach a kid aged 6 about math.\n\nThis is the expected criteria for your + final answer: A topic, explanation, angle, and examples.\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:"}], "model": "gpt-4o-mini", "stop": ["\nObservation:"]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '947' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BLcXHdzyAspGoZqNlbFwEhWe9PLHP\",\n \"object\": + \"chat.completion\",\n \"created\": 1744492719,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": \"I now can give a great answer \\nFinal + Answer: \\n\\n**Topic: Introduction to Basic Addition**\\n\\n**Explanation:**\\nBasic + addition is about combining two or more groups of things together to find out + how many there are in total. It's one of the most fundamental concepts in math + and is a building block for all other math skills. Teaching addition to a 6-year-old + involves using simple numbers and relatable examples that help them visualize + and understand the concept of adding together.\\n\\n**Angle:**\\nTo make the + concept of addition fun and engaging, we can use everyday objects that a child + is familiar with, such as toys, fruits, or drawing items. Incorporating visuals + and interactive elements will keep their attention and help reinforce the idea + of combining numbers.\\n\\n**Examples:**\\n\\n1. **Using Objects:**\\n - **Scenario:** + Let\u2019s say you have 2 apples and your friend gives you 3 more apples.\\n + \ - **Visual**: Arrange the apples in front of the child.\\n - **Question:** + \\\"How many apples do you have now?\\\"\\n - **Calculation:** 2 apples (your + apples) + 3 apples (friend's apples) = 5 apples. \\n - **Conclusion:** \\\"You + now have 5 apples!\\\"\\n\\n2. **Drawing Pictures:**\\n - **Scenario:** Draw + 4 stars on one side of the paper and 2 stars on the other side.\\n - **Activity:** + Ask the child to count the stars in the first group and then the second group.\\n + \ - **Question:** \\\"If we put them together, how many stars do we have?\\\"\\n + \ - **Calculation:** 4 stars + 2 stars = 6 stars. \\n - **Conclusion:** + \\\"You drew 6 stars all together!\\\"\\n\\n3. **Story Problems:**\\n - **Scenario:** + \\\"You have 5 toy cars, and you buy 3 more from the store. How many cars do + you have?\\\"\\n - **Interaction:** Create a fun story around the toy cars + (perhaps the cars are going on an adventure).\\n - **Calculation:** 5 toy + cars + 3 toy cars = 8 toy cars. \\n - **Conclusion:** \\\"You now have a + total of 8 toy cars for your adventure!\\\"\\n\\n4. **Games:**\\n - **Activity:** + Play a simple game where you roll a pair of dice. Each die shows a number.\\n + \ - **Task:** Ask the child to add the numbers on the dice together.\\n - + **Example:** If one die shows 2 and the other shows 4, the child will say \u201C2 + + 4 = 6!\u201D\\n - **Conclusion:** \u201CWhoever gets the highest number + wins a point!\u201D\\n\\nIn summary, when teaching a 6-year-old about basic + addition, it is essential to use simple numbers, real-life examples, visual + aids, and engaging activities. This ensures the child can grasp the concept + while having a fun learning experience. Making math relatable to their world + helps build a strong foundation for their future learning!\",\n \"refusal\": + null,\n \"annotations\": []\n },\n \"logprobs\": null,\n \"finish_reason\": + \"stop\"\n }\n ],\n \"usage\": {\n \"prompt_tokens\": 182,\n \"completion_tokens\": + 614,\n \"total_tokens\": 796,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_44added55e\"\n}\n" + headers: + CF-RAY: + - 92f5c1e79def7dfb-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 21:18:47 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=K4nlFbrAhkeMy3T0CYCEQ8LbGfMw1idnuavkm6jYSlo-1744492727-1.0.1.1-uEkfjA9z_7BDhZ8c48Ldy1uVIKr35Ff_WNPd.C..R3WrIfFIHEuUIvEzlDeCmn81G2dniI435V5iLdkiptCuh4TdMnfyfx9EFuiTKD2RaCk; + path=/; expires=Sat, 12-Apr-25 21:48:47 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=Q23zZGhbuNaTNh.RPoM_1O4jWXLFM.KtSgSytn2NO.Q-1744492727869-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '8422' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999797' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_10c1ab16b9e24f6aab42be321d3fb25a + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["I now can give a great answer Final Answer: **Topic: Introduction + to Basic Addition** **Explanation:** Basic addition is about combining two + or more groups of things together to find out how many there are in total. It''s + one of the most fundamental concepts in math and is a building block for all + other math skills. Teaching addition to a 6-year-old involves using simple numbers + and relatable examples that help them visualize and understand the concept of + adding together. **Angle:** To make the concept of addition fun and engaging, + we can use everyday objects that a child is familiar with, such as toys, fruits, + or drawing items. Incorporating visuals and interactive elements will keep their + attention and help reinforce the idea of combining numbers. **Examples:** 1. + **Using Objects:** - **Scenario:** Let\u2019s say you have 2 apples and your + friend gives you 3 more apples. - **Visual**: Arrange the apples in front + of the child. - **Question:** \"How many apples do you have now?\" - **Calculation:** + 2 apples (your apples) + 3 apples (friend''s apples) = 5 apples. - **Conclusion:** + \"You now have 5 apples!\" 2. **Drawing Pictures:** - **Scenario:** Draw + 4 stars on one side of the paper and 2 stars on the other side. - **Activity:** + Ask the child to count the stars in the first group and then the second group. - + **Question:** \"If we put them together, how many stars do we have?\" - **Calculation:** + 4 stars + 2 stars = 6 stars. - **Conclusion:** \"You drew 6 stars all together!\" 3. + **Story Problems:** - **Scenario:** \"You have 5 toy cars, and you buy 3 + more from the store. How many cars do you have?\" - **Interaction:** Create + a fun story around the toy cars (perhaps the cars are going on an adventure). - + **Calculation:** 5 toy cars + 3 toy cars = 8 toy cars. - **Conclusion:** + \"You now have a total of 8 toy cars for your adventure!\" 4. **Games:** - + **Activity:** Play a simple game where you roll a pair of dice. Each die shows + a number. - **Task:** Ask the child to add the numbers on the dice together. - + **Example:** If one die shows 2 and the other shows 4, the child will say \u201c2 + + 4 = 6!\u201d - **Conclusion:** \u201cWhoever gets the highest number wins + a point!\u201d In summary, when teaching a 6-year-old about basic addition, + it is essential to use simple numbers, real-life examples, visual aids, and + engaging activities. This ensures the child can grasp the concept while having + a fun learning experience. Making math relatable to their world helps build + a strong foundation for their future learning!"], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '2700' + content-type: + - application/json + cookie: + - __cf_bm=EmHz1EYky7JW_ELsgMXI7amRZ4ggf4.6l8BV8FXmAW4-1744492718-1.0.1.1-5huIPLAuZz_NdAPPRxCBl_U6lUxrPRTG4ahM4_M8foKARhQ42CjSvaG96yLvaWGYy6oi27G7S_vkUA11fwrlfvGOyDE_rcr5z1jKKR4ty5M; + _cfuvid=W5j_MoZsp4OTTk_dhG3Vc74tetKESl9eXL85k6nIfqY-1744492718564-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 620,\n \"total_tokens\": 620\n }\n}\n" + headers: + CF-RAY: + - 92f5c21e0e7f7e05-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 21:18:48 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '85' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-7d86d58f9c-62dcs + x-envoy-upstream-service-time: + - '67' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999352' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 3ms + x-request-id: + - req_f643aba459a3868d3baa23e0703ea0e3 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"messages": [{"role": "user", "content": "Assess the quality of the task + completed based on the description, expected output, and actual results.\n\nTask + Description:\nResearch a topic to teach a kid aged 6 about math.\n\nExpected + Output:\nA topic, explanation, angle, and examples.\n\nActual Output:\nI now + can give a great answer \nFinal Answer: \n\n**Topic: Introduction to Basic + Addition**\n\n**Explanation:**\nBasic addition is about combining two or more + groups of things together to find out how many there are in total. It''s one + of the most fundamental concepts in math and is a building block for all other + math skills. Teaching addition to a 6-year-old involves using simple numbers + and relatable examples that help them visualize and understand the concept of + adding together.\n\n**Angle:**\nTo make the concept of addition fun and engaging, + we can use everyday objects that a child is familiar with, such as toys, fruits, + or drawing items. Incorporating visuals and interactive elements will keep their + attention and help reinforce the idea of combining numbers.\n\n**Examples:**\n\n1. + **Using Objects:**\n - **Scenario:** Let\u2019s say you have 2 apples and + your friend gives you 3 more apples.\n - **Visual**: Arrange the apples in + front of the child.\n - **Question:** \"How many apples do you have now?\"\n - + **Calculation:** 2 apples (your apples) + 3 apples (friend''s apples) = 5 apples. \n - + **Conclusion:** \"You now have 5 apples!\"\n\n2. **Drawing Pictures:**\n - + **Scenario:** Draw 4 stars on one side of the paper and 2 stars on the other + side.\n - **Activity:** Ask the child to count the stars in the first group + and then the second group.\n - **Question:** \"If we put them together, how + many stars do we have?\"\n - **Calculation:** 4 stars + 2 stars = 6 stars. \n - + **Conclusion:** \"You drew 6 stars all together!\"\n\n3. **Story Problems:**\n - + **Scenario:** \"You have 5 toy cars, and you buy 3 more from the store. How + many cars do you have?\"\n - **Interaction:** Create a fun story around the + toy cars (perhaps the cars are going on an adventure).\n - **Calculation:** + 5 toy cars + 3 toy cars = 8 toy cars. \n - **Conclusion:** \"You now have + a total of 8 toy cars for your adventure!\"\n\n4. **Games:**\n - **Activity:** + Play a simple game where you roll a pair of dice. Each die shows a number.\n - + **Task:** Ask the child to add the numbers on the dice together.\n - **Example:** + If one die shows 2 and the other shows 4, the child will say \u201c2 + 4 = 6!\u201d\n - + **Conclusion:** \u201cWhoever gets the highest number wins a point!\u201d\n\nIn + summary, when teaching a 6-year-old about basic addition, it is essential to + use simple numbers, real-life examples, visual aids, and engaging activities. + This ensures the child can grasp the concept while having a fun learning experience. + Making math relatable to their world helps build a strong foundation for their + future learning!\n\nPlease provide:\n- Bullet points suggestions to improve + future similar tasks\n- A score from 0 to 10 evaluating on completion, quality, + and overall performance- Entities extracted from the task output, if any, their + type, description, and relationships"}], "model": "gpt-4o-mini", "tool_choice": + {"type": "function", "function": {"name": "TaskEvaluation"}}, "tools": [{"type": + "function", "function": {"name": "TaskEvaluation", "description": "Correctly + extracted `TaskEvaluation` with all the required parameters with correct types", + "parameters": {"$defs": {"Entity": {"properties": {"name": {"description": "The + name of the entity.", "title": "Name", "type": "string"}, "type": {"description": + "The type of the entity.", "title": "Type", "type": "string"}, "description": + {"description": "Description of the entity.", "title": "Description", "type": + "string"}, "relationships": {"description": "Relationships of the entity.", + "items": {"type": "string"}, "title": "Relationships", "type": "array"}}, "required": + ["name", "type", "description", "relationships"], "title": "Entity", "type": + "object"}}, "properties": {"suggestions": {"description": "Suggestions to improve + future similar tasks.", "items": {"type": "string"}, "title": "Suggestions", + "type": "array"}, "quality": {"description": "A score from 0 to 10 evaluating + on completion, quality, and overall performance, all taking into account the + task description, expected output, and the result of the task.", "title": "Quality", + "type": "number"}, "entities": {"description": "Entities extracted from the + task output.", "items": {"$ref": "#/$defs/Entity"}, "title": "Entities", "type": + "array"}}, "required": ["entities", "quality", "suggestions"], "type": "object"}}}]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '4699' + content-type: + - application/json + cookie: + - __cf_bm=K4nlFbrAhkeMy3T0CYCEQ8LbGfMw1idnuavkm6jYSlo-1744492727-1.0.1.1-uEkfjA9z_7BDhZ8c48Ldy1uVIKr35Ff_WNPd.C..R3WrIfFIHEuUIvEzlDeCmn81G2dniI435V5iLdkiptCuh4TdMnfyfx9EFuiTKD2RaCk; + _cfuvid=Q23zZGhbuNaTNh.RPoM_1O4jWXLFM.KtSgSytn2NO.Q-1744492727869-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BLcXQM588JWMibOMoXgM04JVNUayW\",\n \"object\": + \"chat.completion\",\n \"created\": 1744492728,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": null,\n \"tool_calls\": [\n {\n + \ \"id\": \"call_0r93QrLrwIn266MMmlj9KDeV\",\n \"type\": + \"function\",\n \"function\": {\n \"name\": \"TaskEvaluation\",\n + \ \"arguments\": \"{\\\"suggestions\\\":[\\\"Use simpler language + for explanations, as the target audience is a 6-year-old.\\\",\\\"Incorporate + more visual elements or props in the examples.\\\",\\\"Provide additional interactive + activities to engage the child.\\\",\\\"Consider including more real-life scenarios + for better relatability.\\\"],\\\"quality\\\":9,\\\"entities\\\":[{\\\"name\\\":\\\"Basic + Addition\\\",\\\"type\\\":\\\"Mathematical Concept\\\",\\\"description\\\":\\\"The + foundation of arithmetic dealing with the sum of two or more numbers or groups + of objects.\\\",\\\"relationships\\\":[\\\"Is essential for learning further + math concepts.\\\",\\\"Can be taught using visual aids and interactive methods.\\\"]},{\\\"name\\\":\\\"Visual + Aids\\\",\\\"type\\\":\\\"Teaching Tool\\\",\\\"description\\\":\\\"Objects + or images used to help explain concepts visually to aid understanding.\\\",\\\"relationships\\\":[\\\"Supports + the learning of basic addition.\\\",\\\"Enhances engagement during lessons.\\\"]},{\\\"name\\\":\\\"Interactive + Games\\\",\\\"type\\\":\\\"Teaching Method\\\",\\\"description\\\":\\\"Learning + activities that involve participation and movement, making the learning process + fun.\\\",\\\"relationships\\\":[\\\"Facilitates learning through play.\\\",\\\"Encourages + active participation in addition problems.\\\"]}]}\"\n }\n }\n + \ ],\n \"refusal\": null,\n \"annotations\": []\n },\n + \ \"logprobs\": null,\n \"finish_reason\": \"stop\"\n }\n ],\n + \ \"usage\": {\n \"prompt_tokens\": 901,\n \"completion_tokens\": 206,\n + \ \"total_tokens\": 1107,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_44added55e\"\n}\n" + headers: + CF-RAY: + - 92f5c220696e7dfb-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 21:18:51 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '2842' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999223' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_ed8129439a91a55b6c0b526a76c069a1 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Basic Addition(Mathematical Concept): The foundation of arithmetic + dealing with the sum of two or more numbers or groups of objects."], "model": + "text-embedding-3-small", "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '211' + content-type: + - application/json + cookie: + - __cf_bm=nWdwrALuDHGwSXnqBZrJBXSSPHnEseaG_PBL5PAWfl8-1744492719-1.0.1.1-Z3sLE_wR.gk2PzN7zUKeFWF5QvfCyVb1ad25WiOcZNNiKSwT8aw.rupvl1GC.LvaaIHb1BMZH0esXrXO7aWCz.C66bT3ilMVbLgjSJhc.bA; + _cfuvid=I1qVn4HwObmpZbHCIfihkYYxjalVXJj8SvhRNmXBdMA-1744492719162-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 25,\n \"total_tokens\": 25\n }\n}\n" + headers: + CF-RAY: + - 92f5c2337cd77deb-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 21:18:52 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '101' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-79ff4cfc4b-285k7 + x-envoy-upstream-service-time: + - '77' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999967' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_94a17350031061246109c26419bfc4bb + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Visual Aids(Teaching Tool): Objects or images used to help + explain concepts visually to aid understanding."], "model": "text-embedding-3-small", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '185' + content-type: + - application/json + cookie: + - __cf_bm=nWdwrALuDHGwSXnqBZrJBXSSPHnEseaG_PBL5PAWfl8-1744492719-1.0.1.1-Z3sLE_wR.gk2PzN7zUKeFWF5QvfCyVb1ad25WiOcZNNiKSwT8aw.rupvl1GC.LvaaIHb1BMZH0esXrXO7aWCz.C66bT3ilMVbLgjSJhc.bA; + _cfuvid=I1qVn4HwObmpZbHCIfihkYYxjalVXJj8SvhRNmXBdMA-1744492719162-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 21,\n \"total_tokens\": 21\n }\n}\n" + headers: + CF-RAY: + - 92f5c23a89207deb-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 21:18:53 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '80' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-79686db8dc-5lk8m + x-envoy-upstream-service-time: + - '56' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999973' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_98a6e1933f40d726e8535dee8b720d8f + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["Interactive Games(Teaching Method): Learning activities that + involve participation and movement, making the learning process fun."], "model": + "text-embedding-3-small", "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '208' + content-type: + - application/json + cookie: + - __cf_bm=nWdwrALuDHGwSXnqBZrJBXSSPHnEseaG_PBL5PAWfl8-1744492719-1.0.1.1-Z3sLE_wR.gk2PzN7zUKeFWF5QvfCyVb1ad25WiOcZNNiKSwT8aw.rupvl1GC.LvaaIHb1BMZH0esXrXO7aWCz.C66bT3ilMVbLgjSJhc.bA; + _cfuvid=I1qVn4HwObmpZbHCIfihkYYxjalVXJj8SvhRNmXBdMA-1744492719162-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 21,\n \"total_tokens\": 21\n }\n}\n" + headers: + CF-RAY: + - 92f5c23ecbee7deb-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 21:18:53 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '48' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-79686db8dc-cdmmc + x-envoy-upstream-service-time: + - '36' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999968' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_e1e95e8f654254ef093113417ba6ab00 + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/cassettes/test_task_with_max_execution_time.yaml b/tests/cassettes/test_task_with_max_execution_time.yaml new file mode 100644 index 000000000..93e619bc7 --- /dev/null +++ b/tests/cassettes/test_task_with_max_execution_time.yaml @@ -0,0 +1,643 @@ +interactions: +- request: + body: '{"messages": [{"role": "system", "content": "You are Researcher. You''re + an expert researcher, specialized in technology, software engineering, AI and + startups. You work as a freelancer and are now working on doing research and + analysis for a new customer.\nYour personal goal is: Make the best research + and analysis on content about AI and AI agents. Use the tool provided to you.\nYou + ONLY have access to the following tools, and should NEVER make up tools that + are not listed here:\n\nTool Name: what amazing tool\nTool Arguments: {}\nTool + Description: My tool\n\nIMPORTANT: Use the following format in your response:\n\n```\nThought: + you should always think about what to do\nAction: the action to take, only one + name of [what amazing tool], just the name, exactly as it''s written.\nAction + Input: the input to the action, just a simple JSON object, enclosed in curly + braces, using \" to wrap keys and values.\nObservation: the result of the action\n```\n\nOnce + all necessary information is gathered, return the following format:\n\n```\nThought: + I now know the final answer\nFinal Answer: the final answer to the original + input question\n```"}, {"role": "user", "content": "\nCurrent Task: Give me + a list of 5 interesting ideas to explore for an article, what makes them unique + and interesting.\n\nThis is the expected criteria for your final answer: Bullet + point list of 5 interesting ideas.\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:"}], "model": "gpt-4o-mini", "stop": ["\nObservation:"]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '1666' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.11.12 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BNNPLDDeGQYegE6neZK6ogJmDOMYs\",\n \"object\": + \"chat.completion\",\n \"created\": 1744911223,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": \"I need to generate interesting ideas + for an article related to AI and AI agents. \\n\\nAction: what amazing tool + \ \\nAction Input: {} \",\n \"refusal\": null,\n \"annotations\": + []\n },\n \"logprobs\": null,\n \"finish_reason\": \"stop\"\n + \ }\n ],\n \"usage\": {\n \"prompt_tokens\": 326,\n \"completion_tokens\": + 28,\n \"total_tokens\": 354,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_0392822090\"\n}\n" + headers: + CF-RAY: + - 931dab4c79581b2e-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Thu, 17 Apr 2025 17:33:44 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '736' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999620' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_0767caa75d1851f392ea34a68763b1bc + http_version: HTTP/1.1 + status_code: 200 +- request: + body: !!binary | + CqzaAQokCiIKDHNlcnZpY2UubmFtZRISChBjcmV3QUktdGVsZW1ldHJ5EoLaAQoSChBjcmV3YWku + dGVsZW1ldHJ5EpYIChAm+VDVVrKTGFLYrGmqyFN/EgiVIKrLvczC6SoMQ3JldyBDcmVhdGVkMAE5 + uBnOOYMrNxhBWHDXOYMrNxhKGwoOY3Jld2FpX3ZlcnNpb24SCQoHMC4xMTQuMEobCg5weXRob25f + dmVyc2lvbhIJCgczLjExLjEySi4KCGNyZXdfa2V5EiIKIDVlNmVmZmU2ODBhNWQ5N2RjMzg3M2Ix + NDgyNWNjZmEzSjEKB2NyZXdfaWQSJgokMzI4MzZhOTctMGIyYi00MTAwLTgxZDYtYmIwZWJjY2I2 + ZDYyShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRj + cmV3X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBj + cmV3X2ZpbmdlcnByaW50EiYKJGQ5YmEwZDE3LTE5YjMtNGQ5Yi04ZTNmLThiMjNhOGM0YzgyM0o7 + ChtjcmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xN1QxNDozMzo0My4yMzg4 + MzhKzQIKC2NyZXdfYWdlbnRzEr0CCroCW3sia2V5IjogIjkyZTdlYjE5MTY2NGM5MzU3ODVlZDdk + NDI0MGEyOTRkIiwgImlkIjogImMzMWMwNzRmLTg5Y2YtNGRkNi04ZTY2LWM3NDM1OTc0NmNkMSIs + ICJyb2xlIjogIlNjb3JlciIsICJ2ZXJib3NlPyI6IGZhbHNlLCAibWF4X2l0ZXIiOiAyNSwgIm1h + eF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8t + bWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlv + bj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtdfV1K+wEK + CmNyZXdfdGFza3MS7AEK6QFbeyJrZXkiOiAiMjdlZjM4Y2M5OWRhNGE4ZGVkNzBlZDQwNmU0NGFi + ODYiLCAiaWQiOiAiYTNiODU1ODAtZTVjNC00YmU2LWI0ZmItMDU1NDU2Y2RkZWJkIiwgImFzeW5j + X2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6 + ICJTY29yZXIiLCAiYWdlbnRfa2V5IjogIjkyZTdlYjE5MTY2NGM5MzU3ODVlZDdkNDI0MGEyOTRk + IiwgInRvb2xzX25hbWVzIjogW119XXoCGAGFAQABAAASgAQKED9XhldOUhgSlcVbrT/HuRwSCCF7 + 8YboEaZnKgxUYXNrIENyZWF0ZWQwATlYmeU5gys3GEHwx+c5gys3GEouCghjcmV3X2tleRIiCiA1 + ZTZlZmZlNjgwYTVkOTdkYzM4NzNiMTQ4MjVjY2ZhM0oxCgdjcmV3X2lkEiYKJDMyODM2YTk3LTBi + MmItNDEwMC04MWQ2LWJiMGViY2NiNmQ2MkouCgh0YXNrX2tleRIiCiAyN2VmMzhjYzk5ZGE0YThk + ZWQ3MGVkNDA2ZTQ0YWI4NkoxCgd0YXNrX2lkEiYKJGEzYjg1NTgwLWU1YzQtNGJlNi1iNGZiLTA1 + NTQ1NmNkZGViZEo6ChBjcmV3X2ZpbmdlcnByaW50EiYKJGQ5YmEwZDE3LTE5YjMtNGQ5Yi04ZTNm + LThiMjNhOGM0YzgyM0o6ChB0YXNrX2ZpbmdlcnByaW50EiYKJDc0OTEwMDcxLTM1MWQtNDljNy1h + YmZlLTJmMWZhNWUzZTEyYko7Cht0YXNrX2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0w + NC0xN1QxNDozMzo0My4yMzg4MDFKOwoRYWdlbnRfZmluZ2VycHJpbnQSJgokYzMyNmIyMWUtYWJh + YS00N2ZjLWE0NGQtMzk2NTQ4ZjczZTRiegIYAYUBAAEAABKYCAoQH3AbYnQyty/P5gHiJzrjLxII + PR8P3tNCS74qDENyZXcgQ3JlYXRlZDABOYgCyj6DKzcYQSD71D6DKzcYShsKDmNyZXdhaV92ZXJz + aW9uEgkKBzAuMTE0LjBKGwoOcHl0aG9uX3ZlcnNpb24SCQoHMy4xMS4xMkouCghjcmV3X2tleRIi + CiA1ZTZlZmZlNjgwYTVkOTdkYzM4NzNiMTQ4MjVjY2ZhM0oxCgdjcmV3X2lkEiYKJDBkY2JhOGY4 + LTdhYzQtNDdmMC04ZWIxLWE0ZTJkODFjOGZkYkoeCgxjcmV3X3Byb2Nlc3MSDgoMaGllcmFyY2hp + Y2FsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jl + d19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3X2ZpbmdlcnByaW50EiYKJDJiYzYzYWE1LWU5 + YzYtNDAxNi1hMTdiLWFmZDM5ZWJlYmEwNko7ChtjcmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQS + HAoaMjAyNS0wNC0xN1QxNDozMzo0My4zMjI3OTlKzQIKC2NyZXdfYWdlbnRzEr0CCroCW3sia2V5 + IjogIjkyZTdlYjE5MTY2NGM5MzU3ODVlZDdkNDI0MGEyOTRkIiwgImlkIjogImYyY2Y4YWRlLTdj + YmYtNDkwMS1hODMwLWE3ZDkxODA4NjI3NCIsICJyb2xlIjogIlNjb3JlciIsICJ2ZXJib3NlPyI6 + IGZhbHNlLCAibWF4X2l0ZXIiOiAyNSwgIm1heF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGlu + Z19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8tbWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/Ijog + ZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlvbj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6 + IDIsICJ0b29sc19uYW1lcyI6IFtdfV1K+wEKCmNyZXdfdGFza3MS7AEK6QFbeyJrZXkiOiAiMjdl + ZjM4Y2M5OWRhNGE4ZGVkNzBlZDQwNmU0NGFiODYiLCAiaWQiOiAiMWY3MTljNTktOTJjMC00NGU1 + LWFmMjUtNzIwYjE1NWE1Njg1IiwgImFzeW5jX2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lu + cHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6ICJTY29yZXIiLCAiYWdlbnRfa2V5IjogIjkyZTdl + YjE5MTY2NGM5MzU3ODVlZDdkNDI0MGEyOTRkIiwgInRvb2xzX25hbWVzIjogW119XXoCGAGFAQAB + AAASgAQKEIVZhLW3PhEOxntJYQn8IYkSCDNELyrmM+eYKgxUYXNrIENyZWF0ZWQwATlYr+0+gys3 + GEGIJO4+gys3GEouCghjcmV3X2tleRIiCiA1ZTZlZmZlNjgwYTVkOTdkYzM4NzNiMTQ4MjVjY2Zh + M0oxCgdjcmV3X2lkEiYKJDBkY2JhOGY4LTdhYzQtNDdmMC04ZWIxLWE0ZTJkODFjOGZkYkouCgh0 + YXNrX2tleRIiCiAyN2VmMzhjYzk5ZGE0YThkZWQ3MGVkNDA2ZTQ0YWI4NkoxCgd0YXNrX2lkEiYK + JDFmNzE5YzU5LTkyYzAtNDRlNS1hZjI1LTcyMGIxNTVhNTY4NUo6ChBjcmV3X2ZpbmdlcnByaW50 + EiYKJDJiYzYzYWE1LWU5YzYtNDAxNi1hMTdiLWFmZDM5ZWJlYmEwNko6ChB0YXNrX2ZpbmdlcnBy + aW50EiYKJGJmMDU5YjBiLWFlYmYtNGIzMS04YTc4LTA2ZTlmMjcyZDQ2MEo7Cht0YXNrX2Zpbmdl + cnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xN1QxNDozMzo0My4zMjI3NTVKOwoRYWdlbnRf + ZmluZ2VycHJpbnQSJgokY2IzZWQ2ZGQtNzEzNC00YTc3LThiMjctZWIwZGRkZGZlMjdiegIYAYUB + AAEAABKdAQoQ6S1CnqyOxKwRN/Vq7X81HRIIso7ugOmXnjEqClRvb2wgVXNhZ2UwATnAIk4/gys3 + GEE4YlU/gys3GEobCg5jcmV3YWlfdmVyc2lvbhIJCgcwLjExNC4wSigKCXRvb2xfbmFtZRIbChlE + ZWxlZ2F0ZSB3b3JrIHRvIGNvd29ya2VySg4KCGF0dGVtcHRzEgIYAXoCGAGFAQABAAASlggKENaM + zYnzHCL03v+Ihe5ZidsSCIXobzKG03Z6KgxDcmV3IENyZWF0ZWQwATlQ8uM/gys3GEFIfOk/gys3 + GEobCg5jcmV3YWlfdmVyc2lvbhIJCgcwLjExNC4wShsKDnB5dGhvbl92ZXJzaW9uEgkKBzMuMTEu + MTJKLgoIY3Jld19rZXkSIgogNWU2ZWZmZTY4MGE1ZDk3ZGMzODczYjE0ODI1Y2NmYTNKMQoHY3Jl + d19pZBImCiQ5ZmYzZmU1ZC01YmYyLTRlNzEtODU0ZS05OTAyZGYxYzIxYTRKHAoMY3Jld19wcm9j + ZXNzEgwKCnNlcXVlbnRpYWxKEQoLY3Jld19tZW1vcnkSAhAAShoKFGNyZXdfbnVtYmVyX29mX3Rh + c2tzEgIYAUobChVjcmV3X251bWJlcl9vZl9hZ2VudHMSAhgBSjoKEGNyZXdfZmluZ2VycHJpbnQS + JgokOTkwOTQ1YmUtOTczMS00ZTQxLTg5ZDAtYzEzMjljNGQ3NjQ5SjsKG2NyZXdfZmluZ2VycHJp + bnRfY3JlYXRlZF9hdBIcChoyMDI1LTA0LTE3VDE0OjMzOjQzLjM0MTIyM0rNAgoLY3Jld19hZ2Vu + dHMSvQIKugJbeyJrZXkiOiAiOTJlN2ViMTkxNjY0YzkzNTc4NWVkN2Q0MjQwYTI5NGQiLCAiaWQi + OiAiMGM3NDhlNDgtOGNmNC00ZDJhLWFlYWMtZDY5OTUzMDkwZThmIiwgInJvbGUiOiAiU2NvcmVy + IiwgInZlcmJvc2U/IjogZmFsc2UsICJtYXhfaXRlciI6IDI1LCAibWF4X3JwbSI6IG51bGwsICJm + dW5jdGlvbl9jYWxsaW5nX2xsbSI6ICIiLCAibGxtIjogImdwdC00by1taW5pIiwgImRlbGVnYXRp + b25fZW5hYmxlZD8iOiBmYWxzZSwgImFsbG93X2NvZGVfZXhlY3V0aW9uPyI6IGZhbHNlLCAibWF4 + X3JldHJ5X2xpbWl0IjogMiwgInRvb2xzX25hbWVzIjogW119XUr7AQoKY3Jld190YXNrcxLsAQrp + AVt7ImtleSI6ICIyN2VmMzhjYzk5ZGE0YThkZWQ3MGVkNDA2ZTQ0YWI4NiIsICJpZCI6ICI2NzBj + MjdhOS1kYTc3LTRhNTQtYmYxYS1mM2M0YjVlNTcwNDkiLCAiYXN5bmNfZXhlY3V0aW9uPyI6IGZh + bHNlLCAiaHVtYW5faW5wdXQ/IjogZmFsc2UsICJhZ2VudF9yb2xlIjogIlNjb3JlciIsICJhZ2Vu + dF9rZXkiOiAiOTJlN2ViMTkxNjY0YzkzNTc4NWVkN2Q0MjQwYTI5NGQiLCAidG9vbHNfbmFtZXMi + OiBbXX1degIYAYUBAAEAABKABAoQ0PunZB/jswUd8i8ahTz20BIIFtRhrWbDsGIqDFRhc2sgQ3Jl + YXRlZDABOejM8z+DKzcYQZAu9D+DKzcYSi4KCGNyZXdfa2V5EiIKIDVlNmVmZmU2ODBhNWQ5N2Rj + Mzg3M2IxNDgyNWNjZmEzSjEKB2NyZXdfaWQSJgokOWZmM2ZlNWQtNWJmMi00ZTcxLTg1NGUtOTkw + MmRmMWMyMWE0Si4KCHRhc2tfa2V5EiIKIDI3ZWYzOGNjOTlkYTRhOGRlZDcwZWQ0MDZlNDRhYjg2 + SjEKB3Rhc2tfaWQSJgokNjcwYzI3YTktZGE3Ny00YTU0LWJmMWEtZjNjNGI1ZTU3MDQ5SjoKEGNy + ZXdfZmluZ2VycHJpbnQSJgokOTkwOTQ1YmUtOTczMS00ZTQxLTg5ZDAtYzEzMjljNGQ3NjQ5SjoK + EHRhc2tfZmluZ2VycHJpbnQSJgokMjczZmM3YjYtZGJmYS00MzYyLWEwZTEtNzhhNjJjNDY0OTlh + SjsKG3Rhc2tfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoyMDI1LTA0LTE3VDE0OjMzOjQzLjM0 + MTE5NUo7ChFhZ2VudF9maW5nZXJwcmludBImCiQwNTc3MWI4Ny04ZGIzLTRhZGYtOWJhZC0yNzcw + ZjgzYTZiYTN6AhgBhQEAAQAAEpgIChA5RacttE9X5amPuTPHLuYDEgiZ/RIthMTU5yoMQ3JldyBD + cmVhdGVkMAE5EC+lQIMrNxhBsJGsQIMrNxhKGwoOY3Jld2FpX3ZlcnNpb24SCQoHMC4xMTQuMEob + Cg5weXRob25fdmVyc2lvbhIJCgczLjExLjEySi4KCGNyZXdfa2V5EiIKIDVlNmVmZmU2ODBhNWQ5 + N2RjMzg3M2IxNDgyNWNjZmEzSjEKB2NyZXdfaWQSJgokMTc5MzYxNTItNDJmMi00YmY3LWIzOTEt + ZTU0MDU1ZTY2NGU4Sh4KDGNyZXdfcHJvY2VzcxIOCgxoaWVyYXJjaGljYWxKEQoLY3Jld19tZW1v + cnkSAhAAShoKFGNyZXdfbnVtYmVyX29mX3Rhc2tzEgIYAUobChVjcmV3X251bWJlcl9vZl9hZ2Vu + dHMSAhgBSjoKEGNyZXdfZmluZ2VycHJpbnQSJgokNjI0ZTI1NjEtMDFkOC00YmNkLWJhMjEtZDcx + ZTQ0MTZkNGJiSjsKG2NyZXdfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoyMDI1LTA0LTE3VDE0 + OjMzOjQzLjM1Mzg3M0rNAgoLY3Jld19hZ2VudHMSvQIKugJbeyJrZXkiOiAiOTJlN2ViMTkxNjY0 + YzkzNTc4NWVkN2Q0MjQwYTI5NGQiLCAiaWQiOiAiYTEyMTFiNmYtMzFhMy00MzY4LWI5YzItZDNh + NjA1NTZlOTk2IiwgInJvbGUiOiAiU2NvcmVyIiwgInZlcmJvc2U/IjogZmFsc2UsICJtYXhfaXRl + ciI6IDI1LCAibWF4X3JwbSI6IG51bGwsICJmdW5jdGlvbl9jYWxsaW5nX2xsbSI6ICIiLCAibGxt + IjogImdwdC00by1taW5pIiwgImRlbGVnYXRpb25fZW5hYmxlZD8iOiBmYWxzZSwgImFsbG93X2Nv + ZGVfZXhlY3V0aW9uPyI6IGZhbHNlLCAibWF4X3JldHJ5X2xpbWl0IjogMiwgInRvb2xzX25hbWVz + IjogW119XUr7AQoKY3Jld190YXNrcxLsAQrpAVt7ImtleSI6ICIyN2VmMzhjYzk5ZGE0YThkZWQ3 + MGVkNDA2ZTQ0YWI4NiIsICJpZCI6ICI3ZjJjNGIxMi00MjNhLTRmMTctOTZiMS0zZmEyNmUzMDM3 + MmMiLCAiYXN5bmNfZXhlY3V0aW9uPyI6IGZhbHNlLCAiaHVtYW5faW5wdXQ/IjogZmFsc2UsICJh + Z2VudF9yb2xlIjogIlNjb3JlciIsICJhZ2VudF9rZXkiOiAiOTJlN2ViMTkxNjY0YzkzNTc4NWVk + N2Q0MjQwYTI5NGQiLCAidG9vbHNfbmFtZXMiOiBbXX1degIYAYUBAAEAABKABAoQG2i2Mf2AK81I + gFDuyTZ4hxIIGTCH8bEW9REqDFRhc2sgQ3JlYXRlZDABOajZvECDKzcYQbArvUCDKzcYSi4KCGNy + ZXdfa2V5EiIKIDVlNmVmZmU2ODBhNWQ5N2RjMzg3M2IxNDgyNWNjZmEzSjEKB2NyZXdfaWQSJgok + MTc5MzYxNTItNDJmMi00YmY3LWIzOTEtZTU0MDU1ZTY2NGU4Si4KCHRhc2tfa2V5EiIKIDI3ZWYz + OGNjOTlkYTRhOGRlZDcwZWQ0MDZlNDRhYjg2SjEKB3Rhc2tfaWQSJgokN2YyYzRiMTItNDIzYS00 + ZjE3LTk2YjEtM2ZhMjZlMzAzNzJjSjoKEGNyZXdfZmluZ2VycHJpbnQSJgokNjI0ZTI1NjEtMDFk + OC00YmNkLWJhMjEtZDcxZTQ0MTZkNGJiSjoKEHRhc2tfZmluZ2VycHJpbnQSJgokZjViNmU5YjUt + ZjcxMi00YzM3LTkyYjAtMWFjNzQ2ZTYzYWJjSjsKG3Rhc2tfZmluZ2VycHJpbnRfY3JlYXRlZF9h + dBIcChoyMDI1LTA0LTE3VDE0OjMzOjQzLjM1Mzg0M0o7ChFhZ2VudF9maW5nZXJwcmludBImCiQ1 + ZjhkM2YwYS1lODZhLTRiMmUtYWFmMC1jOWMyMDg2N2M1ODR6AhgBhQEAAQAAEpwBChBCoZs2F2Pk + GqD1dlo+B0jIEgh/8w+r7HLXDioKVG9vbCBVc2FnZTABOfhQHUGDKzcYQeChJUGDKzcYShsKDmNy + ZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKJwoJdG9vbF9uYW1lEhoKGEFzayBxdWVzdGlvbiB0byBj + b3dvcmtlckoOCghhdHRlbXB0cxICGAF6AhgBhQEAAQAAEpYIChAtKHG1/6WFVXbuKiUU/tulEggA + 5PFku/BBtSoMQ3JldyBDcmVhdGVkMAE5qOuzQYMrNxhBYNO5QYMrNxhKGwoOY3Jld2FpX3ZlcnNp + b24SCQoHMC4xMTQuMEobCg5weXRob25fdmVyc2lvbhIJCgczLjExLjEySi4KCGNyZXdfa2V5EiIK + IDVlNmVmZmU2ODBhNWQ5N2RjMzg3M2IxNDgyNWNjZmEzSjEKB2NyZXdfaWQSJgokNWQzODQyMmQt + NTk2MC00NGQ0LWFmZjctYWM5MDFiMjU1NzM5ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFs + ShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19u + dW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3X2ZpbmdlcnByaW50EiYKJGZhNWYxODc1LWRiYTQt + NDc2MS04ZDk4LTliNzlmNDg2ZTNlY0o7ChtjcmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoa + MjAyNS0wNC0xN1QxNDozMzo0My4zNzE2MzZKzQIKC2NyZXdfYWdlbnRzEr0CCroCW3sia2V5Ijog + IjkyZTdlYjE5MTY2NGM5MzU3ODVlZDdkNDI0MGEyOTRkIiwgImlkIjogIjgwZDg1ZDY3LTg3M2Qt + NDFhNi05MzY1LWJkODVjYTc5MGI2MyIsICJyb2xlIjogIlNjb3JlciIsICJ2ZXJib3NlPyI6IGZh + bHNlLCAibWF4X2l0ZXIiOiAyNSwgIm1heF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19s + bG0iOiAiIiwgImxsbSI6ICJncHQtNG8tbWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFs + c2UsICJhbGxvd19jb2RlX2V4ZWN1dGlvbj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIs + ICJ0b29sc19uYW1lcyI6IFtdfV1K+wEKCmNyZXdfdGFza3MS7AEK6QFbeyJrZXkiOiAiMjdlZjM4 + Y2M5OWRhNGE4ZGVkNzBlZDQwNmU0NGFiODYiLCAiaWQiOiAiZWYwNmQ3NTEtZWY2Yy00YjJiLWI2 + MTQtMmVhMmU1NGM0MjVlIiwgImFzeW5jX2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0 + PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6ICJTY29yZXIiLCAiYWdlbnRfa2V5IjogIjkyZTdlYjE5 + MTY2NGM5MzU3ODVlZDdkNDI0MGEyOTRkIiwgInRvb2xzX25hbWVzIjogW119XXoCGAGFAQABAAAS + gAQKEJUYH+zYJdlQxAU/SEz07wwSCHIyR0YIxKoQKgxUYXNrIENyZWF0ZWQwATnYg8NBgys3GEFQ + 7cNBgys3GEouCghjcmV3X2tleRIiCiA1ZTZlZmZlNjgwYTVkOTdkYzM4NzNiMTQ4MjVjY2ZhM0ox + CgdjcmV3X2lkEiYKJDVkMzg0MjJkLTU5NjAtNDRkNC1hZmY3LWFjOTAxYjI1NTczOUouCgh0YXNr + X2tleRIiCiAyN2VmMzhjYzk5ZGE0YThkZWQ3MGVkNDA2ZTQ0YWI4NkoxCgd0YXNrX2lkEiYKJGVm + MDZkNzUxLWVmNmMtNGIyYi1iNjE0LTJlYTJlNTRjNDI1ZUo6ChBjcmV3X2ZpbmdlcnByaW50EiYK + JGZhNWYxODc1LWRiYTQtNDc2MS04ZDk4LTliNzlmNDg2ZTNlY0o6ChB0YXNrX2ZpbmdlcnByaW50 + EiYKJDA1ZTU2ZTIzLWI5YjgtNDIwMy05MWYwLTY2ZmE5MDgzNzYzNUo7Cht0YXNrX2ZpbmdlcnBy + aW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xN1QxNDozMzo0My4zNzE2MDJKOwoRYWdlbnRfZmlu + Z2VycHJpbnQSJgokZGZiMDEzYTItNzg0MC00NDFhLTg1YzMtMzI0OWQ1OGJhNmIzegIYAYUBAAEA + ABKWCAoQ67KSQgBBFIpwJAjqKwKTNxIIPHptHAGKIGYqDENyZXcgQ3JlYXRlZDABOeB7T0KDKzcY + QVhEVUKDKzcYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGwoOcHl0aG9uX3ZlcnNpb24S + CQoHMy4xMS4xMkouCghjcmV3X2tleRIiCiA1ZTZlZmZlNjgwYTVkOTdkYzM4NzNiMTQ4MjVjY2Zh + M0oxCgdjcmV3X2lkEiYKJDRmOTE0YWZhLTVlMTAtNDU3Ni1hYjJjLWVkZmNlZWQzYTZiYkocCgxj + cmV3X3Byb2Nlc3MSDAoKc2VxdWVudGlhbEoRCgtjcmV3X21lbW9yeRICEABKGgoUY3Jld19udW1i + ZXJfb2ZfdGFza3MSAhgBShsKFWNyZXdfbnVtYmVyX29mX2FnZW50cxICGAFKOgoQY3Jld19maW5n + ZXJwcmludBImCiQzODFkOTIwYi1iMGE1LTRiNGUtYTQ0OS1kZjg5OGNjZjVmZDdKOwobY3Jld19m + aW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIwMjUtMDQtMTdUMTQ6MzM6NDMuMzgxODc1Ss0CCgtj + cmV3X2FnZW50cxK9Agq6Alt7ImtleSI6ICI5MmU3ZWIxOTE2NjRjOTM1Nzg1ZWQ3ZDQyNDBhMjk0 + ZCIsICJpZCI6ICI5ZjVhZTRmOC02MjkwLTQ5NTUtOGI2OC00YmNjOTM5ZjhhMDkiLCAicm9sZSI6 + ICJTY29yZXIiLCAidmVyYm9zZT8iOiBmYWxzZSwgIm1heF9pdGVyIjogMjUsICJtYXhfcnBtIjog + bnVsbCwgImZ1bmN0aW9uX2NhbGxpbmdfbGxtIjogIiIsICJsbG0iOiAiZ3B0LTRvLW1pbmkiLCAi + ZGVsZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRpb24/IjogZmFs + c2UsICJtYXhfcmV0cnlfbGltaXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX1dSvsBCgpjcmV3X3Rh + c2tzEuwBCukBW3sia2V5IjogIjI3ZWYzOGNjOTlkYTRhOGRlZDcwZWQ0MDZlNDRhYjg2IiwgImlk + IjogIjViODI1OWU3LWI2Y2YtNGJlYi1iYTRiLWY3MDg4Y2E4YWM3NiIsICJhc3luY19leGVjdXRp + b24/IjogZmFsc2UsICJodW1hbl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUiOiAiU2NvcmVy + IiwgImFnZW50X2tleSI6ICI5MmU3ZWIxOTE2NjRjOTM1Nzg1ZWQ3ZDQyNDBhMjk0ZCIsICJ0b29s + c19uYW1lcyI6IFtdfV16AhgBhQEAAQAAEoAEChCDE114uxBCLFPLICeD1DCNEgiFJ3IambqX4yoM + VGFzayBDcmVhdGVkMAE5+P9iQoMrNxhBcGljQoMrNxhKLgoIY3Jld19rZXkSIgogNWU2ZWZmZTY4 + MGE1ZDk3ZGMzODczYjE0ODI1Y2NmYTNKMQoHY3Jld19pZBImCiQ0ZjkxNGFmYS01ZTEwLTQ1NzYt + YWIyYy1lZGZjZWVkM2E2YmJKLgoIdGFza19rZXkSIgogMjdlZjM4Y2M5OWRhNGE4ZGVkNzBlZDQw + NmU0NGFiODZKMQoHdGFza19pZBImCiQ1YjgyNTllNy1iNmNmLTRiZWItYmE0Yi1mNzA4OGNhOGFj + NzZKOgoQY3Jld19maW5nZXJwcmludBImCiQzODFkOTIwYi1iMGE1LTRiNGUtYTQ0OS1kZjg5OGNj + ZjVmZDdKOgoQdGFza19maW5nZXJwcmludBImCiRmZWIzZDVjYy0yMzEwLTRhNDgtOWQ5My1jMzQ5 + MTI0MGU3NTlKOwobdGFza19maW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIwMjUtMDQtMTdUMTQ6 + MzM6NDMuMzgxODQ4SjsKEWFnZW50X2ZpbmdlcnByaW50EiYKJDdhYzY3YTkzLTkwNjctNGJjNC1i + NmFmLTcxZWVjZmRjNzEzOHoCGAGFAQABAAASmAgKEGmCIFMw9GayxClAketnXWsSCPvb3mKDZYhn + KgxDcmV3IENyZWF0ZWQwATkA88JGgys3GEGAhMpGgys3GEobCg5jcmV3YWlfdmVyc2lvbhIJCgcw + LjExNC4wShsKDnB5dGhvbl92ZXJzaW9uEgkKBzMuMTEuMTJKLgoIY3Jld19rZXkSIgogNWU2ZWZm + ZTY4MGE1ZDk3ZGMzODczYjE0ODI1Y2NmYTNKMQoHY3Jld19pZBImCiRmNmE1MGVkMy02ODk5LTQ4 + MTItODVkNy1iNDZlYTQyNzUwN2FKHgoMY3Jld19wcm9jZXNzEg4KDGhpZXJhcmNoaWNhbEoRCgtj + cmV3X21lbW9yeRICEABKGgoUY3Jld19udW1iZXJfb2ZfdGFza3MSAhgBShsKFWNyZXdfbnVtYmVy + X29mX2FnZW50cxICGAFKOgoQY3Jld19maW5nZXJwcmludBImCiQzYzRlM2VmZS01YmQ0LTRkNDgt + YThmNS0yOGY0NDdhNDI0OGRKOwobY3Jld19maW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIwMjUt + MDQtMTdUMTQ6MzM6NDMuNDU2MDg4Ss0CCgtjcmV3X2FnZW50cxK9Agq6Alt7ImtleSI6ICI5MmU3 + ZWIxOTE2NjRjOTM1Nzg1ZWQ3ZDQyNDBhMjk0ZCIsICJpZCI6ICJmNzMwNTE0Mi1jOTViLTQ0MmQt + YjJiOS1jYTVhN2IzMzZlYjMiLCAicm9sZSI6ICJTY29yZXIiLCAidmVyYm9zZT8iOiBmYWxzZSwg + Im1heF9pdGVyIjogMjUsICJtYXhfcnBtIjogbnVsbCwgImZ1bmN0aW9uX2NhbGxpbmdfbGxtIjog + IiIsICJsbG0iOiAiZ3B0LTRvLW1pbmkiLCAiZGVsZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNlLCAi + YWxsb3dfY29kZV9leGVjdXRpb24/IjogZmFsc2UsICJtYXhfcmV0cnlfbGltaXQiOiAyLCAidG9v + bHNfbmFtZXMiOiBbXX1dSvsBCgpjcmV3X3Rhc2tzEuwBCukBW3sia2V5IjogIjI3ZWYzOGNjOTlk + YTRhOGRlZDcwZWQ0MDZlNDRhYjg2IiwgImlkIjogIjU5MDRiMDg5LTMzNzYtNDZhMy04NWU1LTRk + ZTc0NDQyYTljYyIsICJhc3luY19leGVjdXRpb24/IjogZmFsc2UsICJodW1hbl9pbnB1dD8iOiBm + YWxzZSwgImFnZW50X3JvbGUiOiAiU2NvcmVyIiwgImFnZW50X2tleSI6ICI5MmU3ZWIxOTE2NjRj + OTM1Nzg1ZWQ3ZDQyNDBhMjk0ZCIsICJ0b29sc19uYW1lcyI6IFtdfV16AhgBhQEAAQAAEoAEChD9 + DkCz0iVsHA4a1S3+yN8lEgjsMseCiYSvFioMVGFzayBDcmVhdGVkMAE5+ATcRoMrNxhB0F7cRoMr + NxhKLgoIY3Jld19rZXkSIgogNWU2ZWZmZTY4MGE1ZDk3ZGMzODczYjE0ODI1Y2NmYTNKMQoHY3Jl + d19pZBImCiRmNmE1MGVkMy02ODk5LTQ4MTItODVkNy1iNDZlYTQyNzUwN2FKLgoIdGFza19rZXkS + IgogMjdlZjM4Y2M5OWRhNGE4ZGVkNzBlZDQwNmU0NGFiODZKMQoHdGFza19pZBImCiQ1OTA0YjA4 + OS0zMzc2LTQ2YTMtODVlNS00ZGU3NDQ0MmE5Y2NKOgoQY3Jld19maW5nZXJwcmludBImCiQzYzRl + M2VmZS01YmQ0LTRkNDgtYThmNS0yOGY0NDdhNDI0OGRKOgoQdGFza19maW5nZXJwcmludBImCiQ3 + MjExMmY3OS1iMWU3LTRkYTctYTg4YS00NjU3NTJiZTIwZDdKOwobdGFza19maW5nZXJwcmludF9j + cmVhdGVkX2F0EhwKGjIwMjUtMDQtMTdUMTQ6MzM6NDMuNDU2MDU5SjsKEWFnZW50X2ZpbmdlcnBy + aW50EiYKJGJiMzQ0NzIxLTE3M2QtNGRmNS1iMWRmLWQ2NjBkZjZlZmVjZnoCGAGFAQABAAASnAEK + EOg/b+TBCd7kQOaEdNwvgZoSCGYJctohLuuaKgpUb29sIFVzYWdlMAE58JA0R4MrNxhBqOM9R4Mr + NxhKGwoOY3Jld2FpX3ZlcnNpb24SCQoHMC4xMTQuMEonCgl0b29sX25hbWUSGgoYQXNrIHF1ZXN0 + aW9uIHRvIGNvd29ya2VySg4KCGF0dGVtcHRzEgIYAXoCGAGFAQABAAASlwoKEMn/aYwi4Jc7AohP + Y7puRXsSCB83OjVnCZfLKgxDcmV3IENyZWF0ZWQwATlw8dVHgys3GEGA9NtHgys3GEobCg5jcmV3 + YWlfdmVyc2lvbhIJCgcwLjExNC4wShsKDnB5dGhvbl92ZXJzaW9uEgkKBzMuMTEuMTJKLgoIY3Jl + d19rZXkSIgogZDQyNjA4MzNhYjBjMjBiYjQ0OTIyYzc5OWFhOTZiNGFKMQoHY3Jld19pZBImCiQx + ZjA0NjU0YS05ODE5LTQ0MTEtOTVlZC1kMmMwMTJlNWU3YjJKHAoMY3Jld19wcm9jZXNzEgwKCnNl + cXVlbnRpYWxKEQoLY3Jld19tZW1vcnkSAhAAShoKFGNyZXdfbnVtYmVyX29mX3Rhc2tzEgIYAkob + ChVjcmV3X251bWJlcl9vZl9hZ2VudHMSAhgBSjoKEGNyZXdfZmluZ2VycHJpbnQSJgokYjhhYjU0 + YzEtYjFjZS00OGIyLTlkODMtNDVkNzkyMTkxOWQ0SjsKG2NyZXdfZmluZ2VycHJpbnRfY3JlYXRl + ZF9hdBIcChoyMDI1LTA0LTE3VDE0OjMzOjQzLjQ3NDIyN0rlAgoLY3Jld19hZ2VudHMS1QIK0gJb + eyJrZXkiOiAiOTJlN2ViMTkxNjY0YzkzNTc4NWVkN2Q0MjQwYTI5NGQiLCAiaWQiOiAiMjg5YzIz + NzgtNWUxOC00YzJiLWE1NDMtNzVkOTk5YWUyYWQyIiwgInJvbGUiOiAiU2NvcmVyIiwgInZlcmJv + c2U/IjogdHJ1ZSwgIm1heF9pdGVyIjogMjUsICJtYXhfcnBtIjogbnVsbCwgImZ1bmN0aW9uX2Nh + bGxpbmdfbGxtIjogImdwdC0zLjUtdHVyYm8tMDEyNSIsICJsbG0iOiAiZ3B0LTQtMDEyNS1wcmV2 + aWV3IiwgImRlbGVnYXRpb25fZW5hYmxlZD8iOiBmYWxzZSwgImFsbG93X2NvZGVfZXhlY3V0aW9u + PyI6IGZhbHNlLCAibWF4X3JldHJ5X2xpbWl0IjogMiwgInRvb2xzX25hbWVzIjogW119XUrkAwoK + Y3Jld190YXNrcxLVAwrSA1t7ImtleSI6ICIyN2VmMzhjYzk5ZGE0YThkZWQ3MGVkNDA2ZTQ0YWI4 + NiIsICJpZCI6ICJiNTAxMWUwNi02YTdmLTQzYWItYWQzNy1mNGI4ODBhMmJlYjgiLCAiYXN5bmNf + ZXhlY3V0aW9uPyI6IGZhbHNlLCAiaHVtYW5faW5wdXQ/IjogZmFsc2UsICJhZ2VudF9yb2xlIjog + IlNjb3JlciIsICJhZ2VudF9rZXkiOiAiOTJlN2ViMTkxNjY0YzkzNTc4NWVkN2Q0MjQwYTI5NGQi + LCAidG9vbHNfbmFtZXMiOiBbXX0sIHsia2V5IjogIjYwOWRlZTM5MTA4OGNkMWM4N2I4ZmE2NmFh + NjdhZGJlIiwgImlkIjogIjRiODE5NjQ5LTYyMjQtNGQ3Mi1hZDFkLTM0ODZhYzBkODQwNSIsICJh + c3luY19leGVjdXRpb24/IjogZmFsc2UsICJodW1hbl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3Jv + bGUiOiAiU2NvcmVyIiwgImFnZW50X2tleSI6ICI5MmU3ZWIxOTE2NjRjOTM1Nzg1ZWQ3ZDQyNDBh + Mjk0ZCIsICJ0b29sc19uYW1lcyI6IFtdfV16AhgBhQEAAQAAEoAEChCdiwcYoV5twj//vpjaNfMl + EghUv7y5H7+dXioMVGFzayBDcmVhdGVkMAE5wN3kR4MrNxhBsDPlR4MrNxhKLgoIY3Jld19rZXkS + IgogZDQyNjA4MzNhYjBjMjBiYjQ0OTIyYzc5OWFhOTZiNGFKMQoHY3Jld19pZBImCiQxZjA0NjU0 + YS05ODE5LTQ0MTEtOTVlZC1kMmMwMTJlNWU3YjJKLgoIdGFza19rZXkSIgogMjdlZjM4Y2M5OWRh + NGE4ZGVkNzBlZDQwNmU0NGFiODZKMQoHdGFza19pZBImCiRiNTAxMWUwNi02YTdmLTQzYWItYWQz + Ny1mNGI4ODBhMmJlYjhKOgoQY3Jld19maW5nZXJwcmludBImCiRiOGFiNTRjMS1iMWNlLTQ4YjIt + OWQ4My00NWQ3OTIxOTE5ZDRKOgoQdGFza19maW5nZXJwcmludBImCiQ3NDcyMTM3Yi0wYzBkLTRi + OTEtYTgwYy01YzZkYWQwZmM3YTBKOwobdGFza19maW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIw + MjUtMDQtMTdUMTQ6MzM6NDMuNDc0MTc1SjsKEWFnZW50X2ZpbmdlcnByaW50EiYKJDVlMWU1Nzdh + LWY5N2QtNDA2OS04NzNmLTc1ZjYyMDE0ZWJlNnoCGAGFAQABAAASgAQKEA6OsjCwXi+o2MUfKyS+ + TmgSCOIWlM7TtxNCKgxUYXNrIENyZWF0ZWQwATmQ915Igys3GEHYaF9Igys3GEouCghjcmV3X2tl + eRIiCiBkNDI2MDgzM2FiMGMyMGJiNDQ5MjJjNzk5YWE5NmI0YUoxCgdjcmV3X2lkEiYKJDFmMDQ2 + NTRhLTk4MTktNDQxMS05NWVkLWQyYzAxMmU1ZTdiMkouCgh0YXNrX2tleRIiCiA2MDlkZWUzOTEw + ODhjZDFjODdiOGZhNjZhYTY3YWRiZUoxCgd0YXNrX2lkEiYKJDRiODE5NjQ5LTYyMjQtNGQ3Mi1h + ZDFkLTM0ODZhYzBkODQwNUo6ChBjcmV3X2ZpbmdlcnByaW50EiYKJGI4YWI1NGMxLWIxY2UtNDhi + Mi05ZDgzLTQ1ZDc5MjE5MTlkNEo6ChB0YXNrX2ZpbmdlcnByaW50EiYKJGYwZWUxMjY2LWExNzIt + NDhiMi1iMTM2LTczN2I3YWNkYWYwNko7Cht0YXNrX2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoa + MjAyNS0wNC0xN1QxNDozMzo0My40NzQyMDVKOwoRYWdlbnRfZmluZ2VycHJpbnQSJgokNWUxZTU3 + N2EtZjk3ZC00MDY5LTg3M2YtNzVmNjIwMTRlYmU2egIYAYUBAAEAABL/CQoQOon8z16iVXeCtEnr + visR+hII1ztFvfUBPyAqDENyZXcgQ3JlYXRlZDABOYC2CUmDKzcYQVhjEUmDKzcYShsKDmNyZXdh + aV92ZXJzaW9uEgkKBzAuMTE0LjBKGwoOcHl0aG9uX3ZlcnNpb24SCQoHMy4xMS4xMkouCghjcmV3 + X2tleRIiCiBhOTU0MGNkMGVhYTUzZjY3NTQzN2U5YmQ0ZmE1ZTQ0Y0oxCgdjcmV3X2lkEiYKJDFh + MDA5NjZhLTcwYmQtNDc4OS1hZmQxLTY5NjgzMzZjYjc2NkocCgxjcmV3X3Byb2Nlc3MSDAoKc2Vx + dWVudGlhbEoRCgtjcmV3X21lbW9yeRICEABKGgoUY3Jld19udW1iZXJfb2ZfdGFza3MSAhgCShsK + FWNyZXdfbnVtYmVyX29mX2FnZW50cxICGAFKOgoQY3Jld19maW5nZXJwcmludBImCiRjOGI1ZDUx + My0xNzY0LTQyYWQtOGVlYS0wYWU0MDAzZTRmNTRKOwobY3Jld19maW5nZXJwcmludF9jcmVhdGVk + X2F0EhwKGjIwMjUtMDQtMTdUMTQ6MzM6NDMuNDk0ODMySs0CCgtjcmV3X2FnZW50cxK9Agq6Alt7 + ImtleSI6ICI5MmU3ZWIxOTE2NjRjOTM1Nzg1ZWQ3ZDQyNDBhMjk0ZCIsICJpZCI6ICIwZTg1MzFl + YS05MmM4LTQzMGQtYmE0Yy1jMmIxYzkwZDBlMWQiLCAicm9sZSI6ICJTY29yZXIiLCAidmVyYm9z + ZT8iOiBmYWxzZSwgIm1heF9pdGVyIjogMjUsICJtYXhfcnBtIjogbnVsbCwgImZ1bmN0aW9uX2Nh + bGxpbmdfbGxtIjogIiIsICJsbG0iOiAiZ3B0LTRvLW1pbmkiLCAiZGVsZWdhdGlvbl9lbmFibGVk + PyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRpb24/IjogZmFsc2UsICJtYXhfcmV0cnlfbGlt + aXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX1dSuQDCgpjcmV3X3Rhc2tzEtUDCtIDW3sia2V5Ijog + IjI3ZWYzOGNjOTlkYTRhOGRlZDcwZWQ0MDZlNDRhYjg2IiwgImlkIjogImI2NWQ1ZGUzLWY5MjAt + NDVhZi1hOTgwLTA2NjBkMDU5YzdiZiIsICJhc3luY19leGVjdXRpb24/IjogZmFsc2UsICJodW1h + bl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUiOiAiU2NvcmVyIiwgImFnZW50X2tleSI6ICI5 + MmU3ZWIxOTE2NjRjOTM1Nzg1ZWQ3ZDQyNDBhMjk0ZCIsICJ0b29sc19uYW1lcyI6IFtdfSwgeyJr + ZXkiOiAiYjBkMzRhNmY2MjFhN2IzNTgwZDVkMWY0ZTI2NjViOTIiLCAiaWQiOiAiZjk2MDU5NzMt + YzYyMi00NzRjLWFhZjktYWJiOWMwZWZhYmQ0IiwgImFzeW5jX2V4ZWN1dGlvbj8iOiBmYWxzZSwg + Imh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6ICJTY29yZXIiLCAiYWdlbnRfa2V5 + IjogIjkyZTdlYjE5MTY2NGM5MzU3ODVlZDdkNDI0MGEyOTRkIiwgInRvb2xzX25hbWVzIjogW119 + XXoCGAGFAQABAAASgAQKEGysuSY/RpRwwsmMtZmmkLgSCB3RCKVN5vMGKgxUYXNrIENyZWF0ZWQw + ATmYyRpJgys3GEFwIxtJgys3GEouCghjcmV3X2tleRIiCiBhOTU0MGNkMGVhYTUzZjY3NTQzN2U5 + YmQ0ZmE1ZTQ0Y0oxCgdjcmV3X2lkEiYKJDFhMDA5NjZhLTcwYmQtNDc4OS1hZmQxLTY5NjgzMzZj + Yjc2NkouCgh0YXNrX2tleRIiCiAyN2VmMzhjYzk5ZGE0YThkZWQ3MGVkNDA2ZTQ0YWI4NkoxCgd0 + YXNrX2lkEiYKJGI2NWQ1ZGUzLWY5MjAtNDVhZi1hOTgwLTA2NjBkMDU5YzdiZko6ChBjcmV3X2Zp + bmdlcnByaW50EiYKJGM4YjVkNTEzLTE3NjQtNDJhZC04ZWVhLTBhZTQwMDNlNGY1NEo6ChB0YXNr + X2ZpbmdlcnByaW50EiYKJDZjNDhlMTkxLTViMjEtNDBmNi1iNmQwLWRjMWY3ZmM2YWQzN0o7Cht0 + YXNrX2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xN1QxNDozMzo0My40OTQ3NzdK + OwoRYWdlbnRfZmluZ2VycHJpbnQSJgokNTZmYTQ1MTYtM2RiNS00Mjk3LTg3NzUtOTI2MWVhNWI4 + OWI2egIYAYUBAAEAABKABAoQJRURFvAOz5/5e2bQNRT4ChIIpSiy2tnBCrsqDFRhc2sgQ3JlYXRl + ZDABOdgreEmDKzcYQSCdeEmDKzcYSi4KCGNyZXdfa2V5EiIKIGE5NTQwY2QwZWFhNTNmNjc1NDM3 + ZTliZDRmYTVlNDRjSjEKB2NyZXdfaWQSJgokMWEwMDk2NmEtNzBiZC00Nzg5LWFmZDEtNjk2ODMz + NmNiNzY2Si4KCHRhc2tfa2V5EiIKIGIwZDM0YTZmNjIxYTdiMzU4MGQ1ZDFmNGUyNjY1YjkySjEK + B3Rhc2tfaWQSJgokZjk2MDU5NzMtYzYyMi00NzRjLWFhZjktYWJiOWMwZWZhYmQ0SjoKEGNyZXdf + ZmluZ2VycHJpbnQSJgokYzhiNWQ1MTMtMTc2NC00MmFkLThlZWEtMGFlNDAwM2U0ZjU0SjoKEHRh + c2tfZmluZ2VycHJpbnQSJgokMWI0YzI5NTYtMDZkOC00NWNjLWFmYWMtNmZhZDk0MzdkNTZmSjsK + G3Rhc2tfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoyMDI1LTA0LTE3VDE0OjMzOjQzLjQ5NDgw + OEo7ChFhZ2VudF9maW5nZXJwcmludBImCiQ1NmZhNDUxNi0zZGI1LTQyOTctODc3NS05MjYxZWE1 + Yjg5YjZ6AhgBhQEAAQAAEpYIChCt1KD2VBrK6+JIjPGbSQYWEghyEaRdKejivSoMQ3JldyBDcmVh + dGVkMAE54Fn7SYMrNxhBMPkBSoMrNxhKGwoOY3Jld2FpX3ZlcnNpb24SCQoHMC4xMTQuMEobCg5w + eXRob25fdmVyc2lvbhIJCgczLjExLjEySi4KCGNyZXdfa2V5EiIKIDVlNmVmZmU2ODBhNWQ5N2Rj + Mzg3M2IxNDgyNWNjZmEzSjEKB2NyZXdfaWQSJgokMDQ4ZDQ5MzctNmU3OC00OWFkLTllZDMtYzVi + MjdlNDgyNThlShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQ + AEoaChRjcmV3X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIY + AUo6ChBjcmV3X2ZpbmdlcnByaW50EiYKJDIxYjViOWQ3LWVjNTktNDBhYi1iZjY1LTk1NzM2M2Fl + ZDRkZEo7ChtjcmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xN1QxNDozMzo0 + My41MTA0NjZKzQIKC2NyZXdfYWdlbnRzEr0CCroCW3sia2V5IjogIjkyZTdlYjE5MTY2NGM5MzU3 + ODVlZDdkNDI0MGEyOTRkIiwgImlkIjogImFkN2ExMTJiLWY5NDQtNDViYy05YzE4LWJjOWQzMDE4 + NjE1OCIsICJyb2xlIjogIlNjb3JlciIsICJ2ZXJib3NlPyI6IGZhbHNlLCAibWF4X2l0ZXIiOiAy + NSwgIm1heF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJn + cHQtNG8tbWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4 + ZWN1dGlvbj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtd + fV1K+wEKCmNyZXdfdGFza3MS7AEK6QFbeyJrZXkiOiAiMjdlZjM4Y2M5OWRhNGE4ZGVkNzBlZDQw + NmU0NGFiODYiLCAiaWQiOiAiZTJmMDI3YzItZWQ2NC00MDU4LThkNzUtNjQ1OWMzYTllYWIwIiwg + ImFzeW5jX2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRf + cm9sZSI6ICJTY29yZXIiLCAiYWdlbnRfa2V5IjogIjkyZTdlYjE5MTY2NGM5MzU3ODVlZDdkNDI0 + MGEyOTRkIiwgInRvb2xzX25hbWVzIjogW119XXoCGAGFAQABAAASgAQKELdQRmZyaC0pfEDI4tAa + vRsSCCE13pISM1wEKgxUYXNrIENyZWF0ZWQwATmwBwpKgys3GEG4WQpKgys3GEouCghjcmV3X2tl + eRIiCiA1ZTZlZmZlNjgwYTVkOTdkYzM4NzNiMTQ4MjVjY2ZhM0oxCgdjcmV3X2lkEiYKJDA0OGQ0 + OTM3LTZlNzgtNDlhZC05ZWQzLWM1YjI3ZTQ4MjU4ZUouCgh0YXNrX2tleRIiCiAyN2VmMzhjYzk5 + ZGE0YThkZWQ3MGVkNDA2ZTQ0YWI4NkoxCgd0YXNrX2lkEiYKJGUyZjAyN2MyLWVkNjQtNDA1OC04 + ZDc1LTY0NTljM2E5ZWFiMEo6ChBjcmV3X2ZpbmdlcnByaW50EiYKJDIxYjViOWQ3LWVjNTktNDBh + Yi1iZjY1LTk1NzM2M2FlZDRkZEo6ChB0YXNrX2ZpbmdlcnByaW50EiYKJDNmMDU4NDE1LTNkNzUt + NDZhNi05OWFjLTIyZmM5OWM4OTBmM0o7Cht0YXNrX2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoa + MjAyNS0wNC0xN1QxNDozMzo0My41MTA0NDBKOwoRYWdlbnRfZmluZ2VycHJpbnQSJgokMjViMTgx + NjYtYjk3My00ZDM3LWI0OTUtMTI4YmIyMzQyNjhmegIYAYUBAAEAABKWCAoQuKzLEfp7NclRHh6f + Sm2/nxIIucJxIhUlkkwqDENyZXcgQ3JlYXRlZDABOfDOa0qDKzcYQfh/cUqDKzcYShsKDmNyZXdh + aV92ZXJzaW9uEgkKBzAuMTE0LjBKGwoOcHl0aG9uX3ZlcnNpb24SCQoHMy4xMS4xMkouCghjcmV3 + X2tleRIiCiA1ZTZlZmZlNjgwYTVkOTdkYzM4NzNiMTQ4MjVjY2ZhM0oxCgdjcmV3X2lkEiYKJDhl + YzE2ZWQ3LTNiYjItNDkxZC04YjYxLTI3MWYxNmZlOGFlMUocCgxjcmV3X3Byb2Nlc3MSDAoKc2Vx + dWVudGlhbEoRCgtjcmV3X21lbW9yeRICEABKGgoUY3Jld19udW1iZXJfb2ZfdGFza3MSAhgBShsK + FWNyZXdfbnVtYmVyX29mX2FnZW50cxICGAFKOgoQY3Jld19maW5nZXJwcmludBImCiQxN2MxN2Qz + NC1mZWZkLTQ1ZTktYWM2NS00ODY2ZTBlNTgwYTBKOwobY3Jld19maW5nZXJwcmludF9jcmVhdGVk + X2F0EhwKGjIwMjUtMDQtMTdUMTQ6MzM6NDMuNTE4MDI0Ss0CCgtjcmV3X2FnZW50cxK9Agq6Alt7 + ImtleSI6ICI5MmU3ZWIxOTE2NjRjOTM1Nzg1ZWQ3ZDQyNDBhMjk0ZCIsICJpZCI6ICJhODk2OTRm + ZS1lNjE1LTQzOWItOTQ4MC02MmVmZTRiNGY4ODUiLCAicm9sZSI6ICJTY29yZXIiLCAidmVyYm9z + ZT8iOiBmYWxzZSwgIm1heF9pdGVyIjogMjUsICJtYXhfcnBtIjogbnVsbCwgImZ1bmN0aW9uX2Nh + bGxpbmdfbGxtIjogIiIsICJsbG0iOiAiZ3B0LTRvLW1pbmkiLCAiZGVsZWdhdGlvbl9lbmFibGVk + PyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRpb24/IjogZmFsc2UsICJtYXhfcmV0cnlfbGlt + aXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX1dSvsBCgpjcmV3X3Rhc2tzEuwBCukBW3sia2V5Ijog + IjI3ZWYzOGNjOTlkYTRhOGRlZDcwZWQ0MDZlNDRhYjg2IiwgImlkIjogIjMwYjNmYmQ4LWM0MmMt + NDhlYi1hNDdlLTAzNzFlOTFmYTAxYiIsICJhc3luY19leGVjdXRpb24/IjogZmFsc2UsICJodW1h + bl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUiOiAiU2NvcmVyIiwgImFnZW50X2tleSI6ICI5 + MmU3ZWIxOTE2NjRjOTM1Nzg1ZWQ3ZDQyNDBhMjk0ZCIsICJ0b29sc19uYW1lcyI6IFtdfV16AhgB + hQEAAQAAEoAEChBSqrS4nl90w/7Z/EGzEvYpEgj54GNjf+XWQyoMVGFzayBDcmVhdGVkMAE5GJ55 + SoMrNxhBOOx5SoMrNxhKLgoIY3Jld19rZXkSIgogNWU2ZWZmZTY4MGE1ZDk3ZGMzODczYjE0ODI1 + Y2NmYTNKMQoHY3Jld19pZBImCiQ4ZWMxNmVkNy0zYmIyLTQ5MWQtOGI2MS0yNzFmMTZmZThhZTFK + LgoIdGFza19rZXkSIgogMjdlZjM4Y2M5OWRhNGE4ZGVkNzBlZDQwNmU0NGFiODZKMQoHdGFza19p + ZBImCiQzMGIzZmJkOC1jNDJjLTQ4ZWItYTQ3ZS0wMzcxZTkxZmEwMWJKOgoQY3Jld19maW5nZXJw + cmludBImCiQxN2MxN2QzNC1mZWZkLTQ1ZTktYWM2NS00ODY2ZTBlNTgwYTBKOgoQdGFza19maW5n + ZXJwcmludBImCiQ5MGYyODZhZC1lOWQ4LTRkOWUtYjA5MC05YTQyY2I3ZjYzNDhKOwobdGFza19m + aW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIwMjUtMDQtMTdUMTQ6MzM6NDMuNTE3OTk4SjsKEWFn + ZW50X2ZpbmdlcnByaW50EiYKJDhhMTliOTQxLWI4MTgtNDU3MC05NmJjLWZlYWQ4MWNkMjk1NXoC + GAGFAQABAAASlggKEFFBQgm1QyQTSqKMpRKbGjwSCCoFcjlB3aOLKgxDcmV3IENyZWF0ZWQwATlY + /RVLgys3GEEwLR1Lgys3GEobCg5jcmV3YWlfdmVyc2lvbhIJCgcwLjExNC4wShsKDnB5dGhvbl92 + ZXJzaW9uEgkKBzMuMTEuMTJKLgoIY3Jld19rZXkSIgogNWU2ZWZmZTY4MGE1ZDk3ZGMzODczYjE0 + ODI1Y2NmYTNKMQoHY3Jld19pZBImCiQ5NDYyMGE5YS1jMjc1LTRjMjItYjk1OC0zZmZlYWRiOGFl + ZGJKHAoMY3Jld19wcm9jZXNzEgwKCnNlcXVlbnRpYWxKEQoLY3Jld19tZW1vcnkSAhAAShoKFGNy + ZXdfbnVtYmVyX29mX3Rhc2tzEgIYAUobChVjcmV3X251bWJlcl9vZl9hZ2VudHMSAhgBSjoKEGNy + ZXdfZmluZ2VycHJpbnQSJgokNzQzZDgxNDYtZTM0My00Njk0LTljODUtMmVmZWRkMzZhYTlkSjsK + G2NyZXdfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoyMDI1LTA0LTE3VDE0OjMzOjQzLjUyOTAz + MkrNAgoLY3Jld19hZ2VudHMSvQIKugJbeyJrZXkiOiAiOTJlN2ViMTkxNjY0YzkzNTc4NWVkN2Q0 + MjQwYTI5NGQiLCAiaWQiOiAiZWE5NTMyZDktZDczNy00ZTIyLWE3MjItMDg2ODQ4NGViMmY5Iiwg + InJvbGUiOiAiU2NvcmVyIiwgInZlcmJvc2U/IjogZmFsc2UsICJtYXhfaXRlciI6IDI1LCAibWF4 + X3JwbSI6IG51bGwsICJmdW5jdGlvbl9jYWxsaW5nX2xsbSI6ICIiLCAibGxtIjogImdwdC00by1t + aW5pIiwgImRlbGVnYXRpb25fZW5hYmxlZD8iOiBmYWxzZSwgImFsbG93X2NvZGVfZXhlY3V0aW9u + PyI6IGZhbHNlLCAibWF4X3JldHJ5X2xpbWl0IjogMiwgInRvb2xzX25hbWVzIjogW119XUr7AQoK + Y3Jld190YXNrcxLsAQrpAVt7ImtleSI6ICIyN2VmMzhjYzk5ZGE0YThkZWQ3MGVkNDA2ZTQ0YWI4 + NiIsICJpZCI6ICIyMmUyMjZiNC1kNmI5LTRiMzgtOTQwMi05NDY0NTBhOWExZjUiLCAiYXN5bmNf + ZXhlY3V0aW9uPyI6IGZhbHNlLCAiaHVtYW5faW5wdXQ/IjogZmFsc2UsICJhZ2VudF9yb2xlIjog + IlNjb3JlciIsICJhZ2VudF9rZXkiOiAiOTJlN2ViMTkxNjY0YzkzNTc4NWVkN2Q0MjQwYTI5NGQi + LCAidG9vbHNfbmFtZXMiOiBbXX1degIYAYUBAAEAABKABAoQBNXlZK0H3tATZKP2Uw7bBxII0nvw + 9UluHcgqDFRhc2sgQ3JlYXRlZDABOXhiJ0uDKzcYQZiwJ0uDKzcYSi4KCGNyZXdfa2V5EiIKIDVl + NmVmZmU2ODBhNWQ5N2RjMzg3M2IxNDgyNWNjZmEzSjEKB2NyZXdfaWQSJgokOTQ2MjBhOWEtYzI3 + NS00YzIyLWI5NTgtM2ZmZWFkYjhhZWRiSi4KCHRhc2tfa2V5EiIKIDI3ZWYzOGNjOTlkYTRhOGRl + ZDcwZWQ0MDZlNDRhYjg2SjEKB3Rhc2tfaWQSJgokMjJlMjI2YjQtZDZiOS00YjM4LTk0MDItOTQ2 + NDUwYTlhMWY1SjoKEGNyZXdfZmluZ2VycHJpbnQSJgokNzQzZDgxNDYtZTM0My00Njk0LTljODUt + MmVmZWRkMzZhYTlkSjoKEHRhc2tfZmluZ2VycHJpbnQSJgokYjI3M2Q1OTMtYzcxZC00ZWRmLWI0 + NmMtMTkyMmIxY2ZmZjY1SjsKG3Rhc2tfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoyMDI1LTA0 + LTE3VDE0OjMzOjQzLjUyOTAwMko7ChFhZ2VudF9maW5nZXJwcmludBImCiQ5ZWYxZjc4Ny1lZTIz + LTRlNGUtOGJkYi04NGJiNjkwZjlkZjV6AhgBhQEAAQAAEpYIChCLERZYyvqc04xX3gWXPO59EggU + L4MaGDu+FyoMQ3JldyBDcmVhdGVkMAE54NLGS4MrNxhBeGbNS4MrNxhKGwoOY3Jld2FpX3ZlcnNp + b24SCQoHMC4xMTQuMEobCg5weXRob25fdmVyc2lvbhIJCgczLjExLjEySi4KCGNyZXdfa2V5EiIK + IDVlNmVmZmU2ODBhNWQ5N2RjMzg3M2IxNDgyNWNjZmEzSjEKB2NyZXdfaWQSJgokZWI4MDdlMzEt + MGFiZS00NjQ0LWEwZjEtMDM4N2ZkZTYzYWQ1ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFs + ShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19u + dW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3X2ZpbmdlcnByaW50EiYKJDBkZDRmNDNlLTEzNzEt + NDVlNS1iMGNmLWY2ZDE5YTNjNzZkOUo7ChtjcmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoa + MjAyNS0wNC0xN1QxNDozMzo0My41NDA2MzhKzQIKC2NyZXdfYWdlbnRzEr0CCroCW3sia2V5Ijog + IjkyZTdlYjE5MTY2NGM5MzU3ODVlZDdkNDI0MGEyOTRkIiwgImlkIjogImY0ZDM5NzdlLTg4YjAt + NDQ2Zi04YzQ5LThkMjc0NDgwOGQ4NiIsICJyb2xlIjogIlNjb3JlciIsICJ2ZXJib3NlPyI6IGZh + bHNlLCAibWF4X2l0ZXIiOiAyNSwgIm1heF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19s + bG0iOiAiIiwgImxsbSI6ICJncHQtNG8tbWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFs + c2UsICJhbGxvd19jb2RlX2V4ZWN1dGlvbj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIs + ICJ0b29sc19uYW1lcyI6IFtdfV1K+wEKCmNyZXdfdGFza3MS7AEK6QFbeyJrZXkiOiAiMjdlZjM4 + Y2M5OWRhNGE4ZGVkNzBlZDQwNmU0NGFiODYiLCAiaWQiOiAiYjA4MTZmY2QtYjcyMS00YTZkLTk0 + ODQtNDc4YWM4ZDdkYTg4IiwgImFzeW5jX2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0 + PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6ICJTY29yZXIiLCAiYWdlbnRfa2V5IjogIjkyZTdlYjE5 + MTY2NGM5MzU3ODVlZDdkNDI0MGEyOTRkIiwgInRvb2xzX25hbWVzIjogW119XXoCGAGFAQABAAAS + gAQKEB0emJtWTE8969Cle2pbw8QSCFZbdjoOT655KgxUYXNrIENyZWF0ZWQwATlgt9VLgys3GEFo + CdZLgys3GEouCghjcmV3X2tleRIiCiA1ZTZlZmZlNjgwYTVkOTdkYzM4NzNiMTQ4MjVjY2ZhM0ox + CgdjcmV3X2lkEiYKJGViODA3ZTMxLTBhYmUtNDY0NC1hMGYxLTAzODdmZGU2M2FkNUouCgh0YXNr + X2tleRIiCiAyN2VmMzhjYzk5ZGE0YThkZWQ3MGVkNDA2ZTQ0YWI4NkoxCgd0YXNrX2lkEiYKJGIw + ODE2ZmNkLWI3MjEtNGE2ZC05NDg0LTQ3OGFjOGQ3ZGE4OEo6ChBjcmV3X2ZpbmdlcnByaW50EiYK + JDBkZDRmNDNlLTEzNzEtNDVlNS1iMGNmLWY2ZDE5YTNjNzZkOUo6ChB0YXNrX2ZpbmdlcnByaW50 + EiYKJGM1ODIyZGM4LWIyYmYtNDUyZS04YjQ2LWRkNjAyMDNkNTA0Zko7Cht0YXNrX2ZpbmdlcnBy + aW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xN1QxNDozMzo0My41NDA2MDlKOwoRYWdlbnRfZmlu + Z2VycHJpbnQSJgokZjZhMjA0MDYtOTM0Yy00ZjVmLWI1MzMtMDYwMTQwMGUxMTM1egIYAYUBAAEA + ABL4BwoQxJQoNY/stf/qihFVNGkp1hII9x5mkc7Cz5AqDENyZXcgQ3JlYXRlZDABOcB+REyDKzcY + QYA7SkyDKzcYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGwoOcHl0aG9uX3ZlcnNpb24S + CQoHMy4xMS4xMkouCghjcmV3X2tleRIiCiA1ZTZlZmZlNjgwYTVkOTdkYzM4NzNiMTQ4MjVjY2Zh + M0oxCgdjcmV3X2lkEiYKJDY3NmIxNjlhLTI5YTYtNDVhOC05NmNjLTY4MjMyNzgzYmU3NUoeCgxj + cmV3X3Byb2Nlc3MSDgoMaGllcmFyY2hpY2FsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3X251 + bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3X2Zp + bmdlcnByaW50EiYKJDMzZDRkZWU1LWIxOTEtNDAzYy04OWEwLTYyNWJiNjVmMmYxOUo7ChtjcmV3 + X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xN1QxNDozMzo0My41NDg4OThKzQIK + C2NyZXdfYWdlbnRzEr0CCroCW3sia2V5IjogIjkyZTdlYjE5MTY2NGM5MzU3ODVlZDdkNDI0MGEy + OTRkIiwgImlkIjogImE0Mzc1OWYyLTY0NDEtNDNiMy1hOGRjLWYxYmQzMTU3MDdlZiIsICJyb2xl + IjogIlNjb3JlciIsICJ2ZXJib3NlPyI6IGZhbHNlLCAibWF4X2l0ZXIiOiAyNSwgIm1heF9ycG0i + OiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8tbWluaSIs + ICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlvbj8iOiBm + YWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtdfV1K2wEKCmNyZXdf + dGFza3MSzAEKyQFbeyJrZXkiOiAiMjdlZjM4Y2M5OWRhNGE4ZGVkNzBlZDQwNmU0NGFiODYiLCAi + aWQiOiAiMDVmYzk4OWItMDY5Mi00ODAzLTgyMTMtMWQ2ODY5YTYwMTBlIiwgImFzeW5jX2V4ZWN1 + dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6ICJOb25l + IiwgImFnZW50X2tleSI6IG51bGwsICJ0b29sc19uYW1lcyI6IFtdfV16AhgBhQEAAQAAEoAEChDT + QOB/rAOBZumhFuP0yYFYEggS6cvMoHzBYioMVGFzayBDcmVhdGVkMAE5cB9dTIMrNxhBeHFdTIMr + NxhKLgoIY3Jld19rZXkSIgogNWU2ZWZmZTY4MGE1ZDk3ZGMzODczYjE0ODI1Y2NmYTNKMQoHY3Jl + d19pZBImCiQ2NzZiMTY5YS0yOWE2LTQ1YTgtOTZjYy02ODIzMjc4M2JlNzVKLgoIdGFza19rZXkS + IgogMjdlZjM4Y2M5OWRhNGE4ZGVkNzBlZDQwNmU0NGFiODZKMQoHdGFza19pZBImCiQwNWZjOTg5 + Yi0wNjkyLTQ4MDMtODIxMy0xZDY4NjlhNjAxMGVKOgoQY3Jld19maW5nZXJwcmludBImCiQzM2Q0 + ZGVlNS1iMTkxLTQwM2MtODlhMC02MjViYjY1ZjJmMTlKOgoQdGFza19maW5nZXJwcmludBImCiQ2 + MGIzYTVkNi04MWUxLTQzOGYtOTE3Yy0yNjU4MzU4NjdmNzZKOwobdGFza19maW5nZXJwcmludF9j + cmVhdGVkX2F0EhwKGjIwMjUtMDQtMTdUMTQ6MzM6NDMuNTQ4ODcwSjsKEWFnZW50X2ZpbmdlcnBy + aW50EiYKJDgwZjQ2NDkxLWM0YjItNDExNy05MTM2LTZhOTQxZjI5ODBiZHoCGAGFAQABAAASnAEK + EObnhSrs8UQiBg/0Bricu2cSCMFW2rX4WlIFKgpUb29sIFVzYWdlMAE5CJ26TIMrNxhBmE/DTIMr + NxhKGwoOY3Jld2FpX3ZlcnNpb24SCQoHMC4xMTQuMEonCgl0b29sX25hbWUSGgoYQXNrIHF1ZXN0 + aW9uIHRvIGNvd29ya2VySg4KCGF0dGVtcHRzEgIYAXoCGAGFAQABAAAS0AoKEBk04hfXjSFQOWWK + xJFMHB8SCLGFr6R51/OhKgxDcmV3IENyZWF0ZWQwATl4TzNNgys3GEFIMzlNgys3GEobCg5jcmV3 + YWlfdmVyc2lvbhIJCgcwLjExNC4wShsKDnB5dGhvbl92ZXJzaW9uEgkKBzMuMTEuMTJKLgoIY3Jl + d19rZXkSIgogNzQyNzU3MzEyZWY3YmI0ZWUwYjA2NjJkMWMyZTIxNzlKMQoHY3Jld19pZBImCiQ2 + MWRiMTdjYi0xODQ3LTRmYzktOWNkMy1hMDY3ZjRkOGExMzRKHAoMY3Jld19wcm9jZXNzEgwKCnNl + cXVlbnRpYWxKEQoLY3Jld19tZW1vcnkSAhAAShoKFGNyZXdfbnVtYmVyX29mX3Rhc2tzEgIYAUob + ChVjcmV3X251bWJlcl9vZl9hZ2VudHMSAhgCSjoKEGNyZXdfZmluZ2VycHJpbnQSJgokNjQ3OGY2 + MjItZGVlOC00OWYyLTljMDktOGNiOTBjMjEwYzNjSjsKG2NyZXdfZmluZ2VycHJpbnRfY3JlYXRl + ZF9hdBIcChoyMDI1LTA0LTE3VDE0OjMzOjQzLjU2NDI2NEqGBQoLY3Jld19hZ2VudHMS9gQK8wRb + eyJrZXkiOiAiODljZjMxMWI0OGI1MjE2OWQ0MmYzOTI1YzViZTFjNWEiLCAiaWQiOiAiM2E3YjUx + ZGItYzhhZC00ZDU3LWE1OGUtOGIzY2EyYzIxZTI2IiwgInJvbGUiOiAiTWFuYWdlciIsICJ2ZXJi + b3NlPyI6IGZhbHNlLCAibWF4X2l0ZXIiOiAyNSwgIm1heF9ycG0iOiBudWxsLCAiZnVuY3Rpb25f + Y2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8tbWluaSIsICJkZWxlZ2F0aW9uX2VuYWJs + ZWQ/IjogdHJ1ZSwgImFsbG93X2NvZGVfZXhlY3V0aW9uPyI6IGZhbHNlLCAibWF4X3JldHJ5X2xp + bWl0IjogMiwgInRvb2xzX25hbWVzIjogW119LCB7ImtleSI6ICI5MmU3ZWIxOTE2NjRjOTM1Nzg1 + ZWQ3ZDQyNDBhMjk0ZCIsICJpZCI6ICIxNWZiMjExOC0zOTE0LTQ2ZTctODRkZi05M2E5ZDA0ZWVj + M2YiLCAicm9sZSI6ICJTY29yZXIiLCAidmVyYm9zZT8iOiBmYWxzZSwgIm1heF9pdGVyIjogMjUs + ICJtYXhfcnBtIjogbnVsbCwgImZ1bmN0aW9uX2NhbGxpbmdfbGxtIjogIiIsICJsbG0iOiAiZ3B0 + LTRvLW1pbmkiLCAiZGVsZWdhdGlvbl9lbmFibGVkPyI6IHRydWUsICJhbGxvd19jb2RlX2V4ZWN1 + dGlvbj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtdfV1K + /AEKCmNyZXdfdGFza3MS7QEK6gFbeyJrZXkiOiAiMjdlZjM4Y2M5OWRhNGE4ZGVkNzBlZDQwNmU0 + NGFiODYiLCAiaWQiOiAiMzcwNTE2YzQtNWNhMC00NDBjLWE3YTctNWFhMjZiMDQ4MmFmIiwgImFz + eW5jX2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9s + ZSI6ICJNYW5hZ2VyIiwgImFnZW50X2tleSI6ICI4OWNmMzExYjQ4YjUyMTY5ZDQyZjM5MjVjNWJl + MWM1YSIsICJ0b29sc19uYW1lcyI6IFtdfV16AhgBhQEAAQAAEoAEChBGCATWQjaQu6Zpx66QI8ik + Egg05IWKCa/6oyoMVGFzayBDcmVhdGVkMAE54CVFTYMrNxhB0HtFTYMrNxhKLgoIY3Jld19rZXkS + IgogNzQyNzU3MzEyZWY3YmI0ZWUwYjA2NjJkMWMyZTIxNzlKMQoHY3Jld19pZBImCiQ2MWRiMTdj + Yi0xODQ3LTRmYzktOWNkMy1hMDY3ZjRkOGExMzRKLgoIdGFza19rZXkSIgogMjdlZjM4Y2M5OWRh + NGE4ZGVkNzBlZDQwNmU0NGFiODZKMQoHdGFza19pZBImCiQzNzA1MTZjNC01Y2EwLTQ0MGMtYTdh + Ny01YWEyNmIwNDgyYWZKOgoQY3Jld19maW5nZXJwcmludBImCiQ2NDc4ZjYyMi1kZWU4LTQ5ZjIt + OWMwOS04Y2I5MGMyMTBjM2NKOgoQdGFza19maW5nZXJwcmludBImCiQxMWU1ZDRhNi04ODc5LTQx + ZDktYWE3ZS04OTdhNDMzMDhlZWVKOwobdGFza19maW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIw + MjUtMDQtMTdUMTQ6MzM6NDMuNTY0MjMzSjsKEWFnZW50X2ZpbmdlcnByaW50EiYKJGUyMzRlYzA5 + LTk3MzktNGE3Zi04MDgxLTBhNjJkYzNlNzY1ZHoCGAGFAQABAAASnQEKEFjGvzVUde99Ey+6qDaD + oG4SCFWLiXG8McaKKgpUb29sIFVzYWdlMAE5kI2lTYMrNxhBMG2tTYMrNxhKGwoOY3Jld2FpX3Zl + cnNpb24SCQoHMC4xMTQuMEooCgl0b29sX25hbWUSGwoZRGVsZWdhdGUgd29yayB0byBjb3dvcmtl + ckoOCghhdHRlbXB0cxICGAF6AhgBhQEAAQAAEooIChCB+QR8dk6jPImbeJiKh5UYEgj00bY0zkAX + LSoMQ3JldyBDcmVhdGVkMAE5cAkrToMrNxhBKNM1ToMrNxhKGwoOY3Jld2FpX3ZlcnNpb24SCQoH + MC4xMTQuMEobCg5weXRob25fdmVyc2lvbhIJCgczLjExLjEySi4KCGNyZXdfa2V5EiIKIDMwM2I4 + ZWRkNWIwMDg3MTBkNzZhYWY4MjVhNzA5ZTU1SjEKB2NyZXdfaWQSJgokNmUzM2ZiOTItNTZjMC00 + OTY3LTk1MjItZGQ3ZWFhOWY5NjFlSh4KDGNyZXdfcHJvY2VzcxIOCgxoaWVyYXJjaGljYWxKEQoL + Y3Jld19tZW1vcnkSAhAAShoKFGNyZXdfbnVtYmVyX29mX3Rhc2tzEgIYAUobChVjcmV3X251bWJl + cl9vZl9hZ2VudHMSAhgBSjoKEGNyZXdfZmluZ2VycHJpbnQSJgokNDY5MjUyODctOTY2OS00MTRl + LWEwNzctZGVjNDE2ZTE3NDRlSjsKG2NyZXdfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoyMDI1 + LTA0LTE3VDE0OjMzOjQzLjU4MDUyM0rfAgoLY3Jld19hZ2VudHMSzwIKzAJbeyJrZXkiOiAiOTJl + N2ViMTkxNjY0YzkzNTc4NWVkN2Q0MjQwYTI5NGQiLCAiaWQiOiAiNzllZTU5MjktNjdlMy00NjNi + LTljYjEtMjFlNTdjNjZlNGQ4IiwgInJvbGUiOiAiU2NvcmVyIiwgInZlcmJvc2U/IjogZmFsc2Us + ICJtYXhfaXRlciI6IDI1LCAibWF4X3JwbSI6IG51bGwsICJmdW5jdGlvbl9jYWxsaW5nX2xsbSI6 + ICIiLCAibGxtIjogImdwdC00by1taW5pIiwgImRlbGVnYXRpb25fZW5hYmxlZD8iOiBmYWxzZSwg + ImFsbG93X2NvZGVfZXhlY3V0aW9uPyI6IGZhbHNlLCAibWF4X3JldHJ5X2xpbWl0IjogMiwgInRv + b2xzX25hbWVzIjogWyJzY29yaW5nX2V4YW1wbGVzIl19XUrbAQoKY3Jld190YXNrcxLMAQrJAVt7 + ImtleSI6ICJmMzU3NWIwMTNjMjI5NGI3Y2M4ZTgwMzE1NWM4YmE0NiIsICJpZCI6ICJhZTlmMjgz + MC1hY2NhLTRiNmQtOGRjNy01MjMzZmZlYmJhM2QiLCAiYXN5bmNfZXhlY3V0aW9uPyI6IGZhbHNl + LCAiaHVtYW5faW5wdXQ/IjogZmFsc2UsICJhZ2VudF9yb2xlIjogIk5vbmUiLCAiYWdlbnRfa2V5 + IjogbnVsbCwgInRvb2xzX25hbWVzIjogW119XXoCGAGFAQABAAASgAQKEHOf6gKzlTQXpW3qTaF+ + AlQSCIXd9+wt3hyiKgxUYXNrIENyZWF0ZWQwATkws0hOgys3GEE4BUlOgys3GEouCghjcmV3X2tl + eRIiCiAzMDNiOGVkZDViMDA4NzEwZDc2YWFmODI1YTcwOWU1NUoxCgdjcmV3X2lkEiYKJDZlMzNm + YjkyLTU2YzAtNDk2Ny05NTIyLWRkN2VhYTlmOTYxZUouCgh0YXNrX2tleRIiCiBmMzU3NWIwMTNj + MjI5NGI3Y2M4ZTgwMzE1NWM4YmE0NkoxCgd0YXNrX2lkEiYKJGFlOWYyODMwLWFjY2EtNGI2ZC04 + ZGM3LTUyMzNmZmViYmEzZEo6ChBjcmV3X2ZpbmdlcnByaW50EiYKJDQ2OTI1Mjg3LTk2NjktNDE0 + ZS1hMDc3LWRlYzQxNmUxNzQ0ZUo6ChB0YXNrX2ZpbmdlcnByaW50EiYKJDU4ZGVjODNjLWFjZTQt + NGI1Ni05YzhjLWQyZGQ1YjVlMWYyNUo7Cht0YXNrX2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoa + MjAyNS0wNC0xN1QxNDozMzo0My41ODA0OTNKOwoRYWdlbnRfZmluZ2VycHJpbnQSJgokMGVjNzAw + NWEtOGMzOC00N2RlLWI5YzctNjc3ZmFkOTU2ZmMzegIYAYUBAAEAABJpChDdogUTH/ocvPeyU/F2 + dgcNEghEqOA/7aEsiyoQVG9vbCBVc2FnZSBFcnJvcjABOVBbt06DKzcYQajPvU6DKzcYShsKDmNy + ZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjB6AhgBhQEAAQAAEp0BChD7kRw1jX3K2nusXZXPvHyGEghl + QFQp8mFhuCoKVG9vbCBVc2FnZTABORCS/E6DKzcYQXDPBE+DKzcYShsKDmNyZXdhaV92ZXJzaW9u + EgkKBzAuMTE0LjBKKAoJdG9vbF9uYW1lEhsKGURlbGVnYXRlIHdvcmsgdG8gY293b3JrZXJKDgoI + YXR0ZW1wdHMSAhgBegIYAYUBAAEAAA== + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '27952' + Content-Type: + - application/x-protobuf + User-Agent: + - OTel-OTLP-Exporter-Python/1.31.1 + 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: + - Thu, 17 Apr 2025 17:33:47 GMT + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_task_with_max_execution_time_exceeded.yaml b/tests/cassettes/test_task_with_max_execution_time_exceeded.yaml new file mode 100644 index 000000000..a650f1b46 --- /dev/null +++ b/tests/cassettes/test_task_with_max_execution_time_exceeded.yaml @@ -0,0 +1,81 @@ +interactions: +- request: + body: '{"contents": [{"role": "user", "parts": [{"text": "\nCurrent Task: Give + me a list of 5 interesting ideas to explore for an article, what makes them + unique and interesting.\n\nThis is the expected criteria for your final answer: + Bullet point list of 5 interesting ideas.\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:"}]}], "system_instruction": {"parts": [{"text": "You are + Researcher. You''re an expert researcher, specialized in technology, software + engineering, AI and startups. You work as a freelancer and are now working on + doing research and analysis for a new customer.\nYour personal goal is: Make + the best research and analysis on content about AI and AI agents. Use the tool + provided to you.\nYou ONLY have access to the following tools, and should NEVER + make up tools that are not listed here:\n\nTool Name: what amazing tool\nTool + Arguments: {}\nTool Description: My tool\n\nIMPORTANT: Use the following format + in your response:\n\n```\nThought: you should always think about what to do\nAction: + the action to take, only one name of [what amazing tool], just the name, exactly + as it''s written.\nAction Input: the input to the action, just a simple JSON + object, enclosed in curly braces, using \" to wrap keys and values.\nObservation: + the result of the action\n```\n\nOnce all necessary information is gathered, + return the following format:\n\n```\nThought: I now know the final answer\nFinal + Answer: the final answer to the original input question\n```"}]}, "generationConfig": + {"temperature": 0.7, "stop_sequences": ["\nObservation:"]}}' + headers: + accept: + - '*/*' + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '1718' + content-type: + - application/json + host: + - generativelanguage.googleapis.com + user-agent: + - litellm/1.60.2 + method: POST + uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro-latest:generateContent + response: + body: + string: !!binary | + H4sIAAAAAAAC/61STWvbQBC961cMe+klFnJUy8S30JZiaGloTQlEOaylibRktavujtKkxv+9s3Lk + rE2PFUha9r2Z9+ZjlwCISppa1ZLQixXc8Q3AbvwGzBpCQwxMV3zZS0dv3MOzi85MIXwOQWLT2qFp + aQVrMIg1kIUGDTpWA1Wj9PBgHUgDnFJVGkFu7UBwvea7evwxnXwKsH6nNQwegVp+rdUhV4u6hw5h + 66Qynqzr0tKU5roiZc0KfreSQHbyjzLNGDNBsDb9wK52pfg1oHsp2WspPk/OFqC4bIeeQuA/feJz + r60L8LnXC6ZWgw8QC40WOvmIHlBW7ZgMBqNYdgyLhNJS7EXUxv3xfH/x1nxnNYbOdrZGPdH3E0E8 + KKN8+50dWxNoPzbfbsQRlU/NF9v0zm7D/GZZml1dLoti8X4+X+RFvszzPJmkR1ExeK7qK5LkBZHH + NRCcoutpYx/RfLDDuCB5nh10ooU6IRTLV5wsSX0aezVhUWL/kWWVjjctWkKuX2pFL+OWfbrdiKhH + dOZr6lISNfPc5X9SK5anYsnrcA7z+onOq8NgGux4VLN5uphxzbMsuxTJPvkLk2fgU5EDAAA= + headers: + Alt-Svc: + - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000 + Content-Encoding: + - gzip + Content-Type: + - application/json; charset=UTF-8 + Date: + - Thu, 17 Apr 2025 19:00:14 GMT + Server: + - scaffolding on HTTPServer2 + Server-Timing: + - gfet4t7; dur=1972 + Transfer-Encoding: + - chunked + Vary: + - Origin + - X-Origin + - Referer + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-XSS-Protection: + - '0' + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_using_contextual_memory_with_long_term_memory.yaml b/tests/cassettes/test_using_contextual_memory_with_long_term_memory.yaml new file mode 100644 index 000000000..3bc8e706a --- /dev/null +++ b/tests/cassettes/test_using_contextual_memory_with_long_term_memory.yaml @@ -0,0 +1,209 @@ +interactions: +- request: + body: !!binary | + CuAMCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkStwwKEgoQY3Jld2FpLnRl + bGVtZXRyeRKdCAoQe1SuF2c2xWX4juAv74oXphII/LGj/b5w49QqDENyZXcgQ3JlYXRlZDABOcCZ + B6F1rTUYQRhzEqF1rTUYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGgoOcHl0aG9uX3Zl + cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIGM5N2I1ZmViNWQxYjY2YmI1OTAwNmFhYTAx + YTI5Y2Q2SjEKB2NyZXdfaWQSJgokMDU1YWZhNGQtNWU5MS00YWU1LTg4ZTQtMGQ3N2I2OTZiODJl + ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3 + X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3 + X2ZpbmdlcnByaW50EiYKJGI3NzY4MjJlLTU4YzItNDg5Ni05NmVhLTlmNDQzNjc4NThjNko7Chtj + cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xMlQxNzo1MjozMS4zOTkzMTdK + 0QIKC2NyZXdfYWdlbnRzEsECCr4CW3sia2V5IjogIjA3ZDk5YjYzMDQxMWQzNWZkOTA0N2E1MzJk + NTNkZGE3IiwgImlkIjogIjI5MmZlMjI4LTNlYzEtNDE4Zi05NzQzLTFkNTI3ZGY5M2QwYyIsICJy + b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiBmYWxzZSwgIm1heF9pdGVyIjogMjUsICJt + YXhfcnBtIjogbnVsbCwgImZ1bmN0aW9uX2NhbGxpbmdfbGxtIjogIiIsICJsbG0iOiAiZ3B0LTRv + LW1pbmkiLCAiZGVsZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRp + b24/IjogZmFsc2UsICJtYXhfcmV0cnlfbGltaXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX1dSv8B + CgpjcmV3X3Rhc2tzEvABCu0BW3sia2V5IjogIjYzOTk2NTE3ZjNmM2YxYzk0ZDZiYjYxN2FhMGIx + YzRmIiwgImlkIjogIjhlY2E1NTQzLTc3MDEtNDhjMy1hODM1LWI4YWE2YmE3YTMzZSIsICJhc3lu + Y19leGVjdXRpb24/IjogZmFsc2UsICJodW1hbl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUi + OiAiUmVzZWFyY2hlciIsICJhZ2VudF9rZXkiOiAiMDdkOTliNjMwNDExZDM1ZmQ5MDQ3YTUzMmQ1 + M2RkYTciLCAidG9vbHNfbmFtZXMiOiBbXX1degIYAYUBAAEAABKABAoQmqGVrPp33uFfE2WlsNm/ + phIIx0mZ95NGSyIqDFRhc2sgQ3JlYXRlZDABObBlHqF1rTUYQbi3HqF1rTUYSi4KCGNyZXdfa2V5 + EiIKIGM5N2I1ZmViNWQxYjY2YmI1OTAwNmFhYTAxYTI5Y2Q2SjEKB2NyZXdfaWQSJgokMDU1YWZh + NGQtNWU5MS00YWU1LTg4ZTQtMGQ3N2I2OTZiODJlSi4KCHRhc2tfa2V5EiIKIDYzOTk2NTE3ZjNm + M2YxYzk0ZDZiYjYxN2FhMGIxYzRmSjEKB3Rhc2tfaWQSJgokOGVjYTU1NDMtNzcwMS00OGMzLWE4 + MzUtYjhhYTZiYTdhMzNlSjoKEGNyZXdfZmluZ2VycHJpbnQSJgokYjc3NjgyMmUtNThjMi00ODk2 + LTk2ZWEtOWY0NDM2Nzg1OGM2SjoKEHRhc2tfZmluZ2VycHJpbnQSJgokYTk5NjE4ZTYtODFhZC00 + N2YyLWE4ZGEtOTc1NjkzN2YxYmIwSjsKG3Rhc2tfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoy + MDI1LTA0LTEyVDE3OjUyOjMxLjM5ODIxNEo7ChFhZ2VudF9maW5nZXJwcmludBImCiRlZjkxZGYx + NS0zNmNiLTQ0MDQtOWFkMi05MmM1OTQ1NGU2ZTZ6AhgBhQEAAQAA + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '1635' + Content-Type: + - application/x-protobuf + User-Agent: + - OTel-OTLP-Exporter-Python/1.31.1 + 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: + - Sat, 12 Apr 2025 20:52:35 GMT + status: + code: 200 + message: OK +- request: + body: '{"messages": [{"role": "system", "content": "You are Researcher. You''re + an expert in research and you love to learn new things.\nYour personal goal + is: You research about math.\nTo give my best complete final answer to the task + respond using 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 complete + as possible, it must be outcome described.\n\nI MUST use these formats, my job + depends on it!"}, {"role": "user", "content": "\nCurrent Task: Research a topic + to teach a kid aged 6 about math.\n\nThis is the expected criteria for your + final answer: A topic, explanation, angle, and examples.\nyou MUST return the + actual complete content as the final answer, not a summary.\n\n# Useful context: + \n\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:"}], "model": "gpt-4o-mini", "stop": + ["\nObservation:"]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '1031' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BLc7zvaXoFAArOIDK9TrMtdq8kKY0\",\n \"object\": + \"chat.completion\",\n \"created\": 1744491151,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": \"I now can give a great answer. \\nFinal + Answer: \\n\\n**Topic: Introduction to Addition with Fun Objects**\\n\\n**Explanation:** + \ \\nAt its core, addition is all about combining two or more groups of things + to find out how many there are in total. We can think of addition as a way to + bring friends together! Imagine if you have some apples and your friend brings + some more apples; together, you want to find out how many apples there are altogether. + This is the foundation of addition, and it can be made fun and engaging for + a 6-year-old.\\n\\n**Angle:** \\nTo make this relatable and enjoyable, we can + use everyday objects that kids love, such as toys, fruits, or even drawings. + We can create little stories or scenarios that involve addition, turning it + into a game where they get to count and add things together. By using real items, + children can see and feel what addition means, making it easier to grasp the + concept.\\n\\n**Examples:** \\n1. **Using Fruits:** \\n Let's say you have + 3 oranges. You can say, \\\"I have 3 oranges.\\\" Then, if your friend brings + you 2 more oranges, you can introduce the addition by saying, \\\"Now, how many + do we have all together?\\\" \\n - So you would show it as: 3 (oranges you + have) + 2 (oranges your friend brought) = ? \\n To find the answer, you can + count all the oranges together: 1, 2, 3 (your oranges) and 4, 5 (your friend's + oranges). \\n - The answer is 5 oranges in total!\\n\\n2. **Using Toys:** + \ \\n If a child has 4 toy cars and finds 3 more under the couch, we can ask, + \\\"How many cars do you have now?\\\" \\n - Write it down: 4 (toy cars) + + 3 (found cars) = ? \\n Then, count the toy cars together: 1, 2, 3, 4 (original + cars), 5, 6, 7. \\n - The answer is 7 toy cars!\\n\\n3. **Story Scenario:** + \ \\n Create an engaging story: \\\"Once upon a time, there were 2 friendly + puppies. One day, 3 more puppies came to play. How many puppies are playing + now?\\\" \\n - Present it as: 2 (original puppies) + 3 (new puppies) = ? + \ \\n Count the puppies: 1, 2 (the first two) and then 3, 4, 5 (the new ones). + \ \\n - The answer is 5 puppies playing!\\n\\nBy presenting addition through + fun scenarios and interactive counting, a 6-year-old can learn and understand + addition while enjoying the process. They can even use crayons to draw the items + or fruit to count in a playful, hands-on approach. This makes math not just + a subject, but also a delightful adventure!\",\n \"refusal\": null,\n + \ \"annotations\": []\n },\n \"logprobs\": null,\n \"finish_reason\": + \"stop\"\n }\n ],\n \"usage\": {\n \"prompt_tokens\": 206,\n \"completion_tokens\": + 609,\n \"total_tokens\": 815,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_44added55e\"\n}\n" + headers: + CF-RAY: + - 92f59ba1fa19572a-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:52:44 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=C7ejNhC7vNTBO9VtBqzN_ce__mP2Dz8noDo2lIcNBn0-1744491164-1.0.1.1-kQgWk4d54JIGxg_yCJ.7uV9HkU8JXrhpfIth0WHDdqf9ESzAsQyDu0xKVLYnga.xswBnm5kePpuFCcnIqGKgyag31cEyuiFFf6JHTvQcvWI; + path=/; expires=Sat, 12-Apr-25 21:22:44 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=QuvcyYK0MZfY9dNclglrzesXcplWfoZN.rd4J57.xtY-1744491164641-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '12806' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999777' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_49f3c203229149ce08c0813ac4071355 + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/cassettes/test_using_contextual_memory_with_short_term_memory.yaml b/tests/cassettes/test_using_contextual_memory_with_short_term_memory.yaml new file mode 100644 index 000000000..720758ad4 --- /dev/null +++ b/tests/cassettes/test_using_contextual_memory_with_short_term_memory.yaml @@ -0,0 +1,335 @@ +interactions: +- request: + body: !!binary | + CuAMCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkStwwKEgoQY3Jld2FpLnRl + bGVtZXRyeRKdCAoQ7xzvcCOT4PrOc8md0oeT3RIIOq+vIsGQam8qDENyZXcgQ3JlYXRlZDABOejV + 5rl4rTUYQdAs7rl4rTUYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGgoOcHl0aG9uX3Zl + cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIGM5N2I1ZmViNWQxYjY2YmI1OTAwNmFhYTAx + YTI5Y2Q2SjEKB2NyZXdfaWQSJgokNzI2ZTU0NWEtNGEzZC00NzFiLWJiMmQtODM3ZGY4OGQ3ZWY5 + ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3 + X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3 + X2ZpbmdlcnByaW50EiYKJGVhYWVhMmQxLTc4Y2EtNDk2Mi05MmI2LTA5Y2QyMzY1ZmZiMEo7Chtj + cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xMlQxNzo1Mjo0NC43MDE3MjdK + 0QIKC2NyZXdfYWdlbnRzEsECCr4CW3sia2V5IjogIjA3ZDk5YjYzMDQxMWQzNWZkOTA0N2E1MzJk + NTNkZGE3IiwgImlkIjogIjcwMjE0NzVhLTNlMzAtNGYzNS1hMzQxLTA2NjBlYzAwYTMyZiIsICJy + b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiBmYWxzZSwgIm1heF9pdGVyIjogMjUsICJt + YXhfcnBtIjogbnVsbCwgImZ1bmN0aW9uX2NhbGxpbmdfbGxtIjogIiIsICJsbG0iOiAiZ3B0LTRv + LW1pbmkiLCAiZGVsZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRp + b24/IjogZmFsc2UsICJtYXhfcmV0cnlfbGltaXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX1dSv8B + CgpjcmV3X3Rhc2tzEvABCu0BW3sia2V5IjogIjYzOTk2NTE3ZjNmM2YxYzk0ZDZiYjYxN2FhMGIx + YzRmIiwgImlkIjogIjQ0MTQ4YzM4LWI3NTMtNDIzNy1hOTFhLTI0MDllMzExNTFlYiIsICJhc3lu + Y19leGVjdXRpb24/IjogZmFsc2UsICJodW1hbl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUi + OiAiUmVzZWFyY2hlciIsICJhZ2VudF9rZXkiOiAiMDdkOTliNjMwNDExZDM1ZmQ5MDQ3YTUzMmQ1 + M2RkYTciLCAidG9vbHNfbmFtZXMiOiBbXX1degIYAYUBAAEAABKABAoQxWHt0ARtypIweXgPS3Mq + CBIIBl4bQnc1/j8qDFRhc2sgQ3JlYXRlZDABOQBs97l4rTUYQfDB97l4rTUYSi4KCGNyZXdfa2V5 + EiIKIGM5N2I1ZmViNWQxYjY2YmI1OTAwNmFhYTAxYTI5Y2Q2SjEKB2NyZXdfaWQSJgokNzI2ZTU0 + NWEtNGEzZC00NzFiLWJiMmQtODM3ZGY4OGQ3ZWY5Si4KCHRhc2tfa2V5EiIKIDYzOTk2NTE3ZjNm + M2YxYzk0ZDZiYjYxN2FhMGIxYzRmSjEKB3Rhc2tfaWQSJgokNDQxNDhjMzgtYjc1My00MjM3LWE5 + MWEtMjQwOWUzMTE1MWViSjoKEGNyZXdfZmluZ2VycHJpbnQSJgokZWFhZWEyZDEtNzhjYS00OTYy + LTkyYjYtMDljZDIzNjVmZmIwSjoKEHRhc2tfZmluZ2VycHJpbnQSJgokMzA5Y2M3NDgtMzliMS00 + NzMyLWFkOWYtNjI4OGJiOTVkZTU4SjsKG3Rhc2tfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoy + MDI1LTA0LTEyVDE3OjUyOjQ0LjU5ODAzNEo7ChFhZ2VudF9maW5nZXJwcmludBImCiQyMDA1ZWFj + Zi03Mzk4LTRiZjEtYjQxNS01NWZkZjE1MTg5ZDF6AhgBhQEAAQAA + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '1635' + Content-Type: + - application/x-protobuf + User-Agent: + - OTel-OTLP-Exporter-Python/1.31.1 + 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: + - Sat, 12 Apr 2025 20:52:45 GMT + status: + code: 200 + message: OK +- request: + body: '{"messages": [{"role": "system", "content": "You are Researcher. You''re + an expert in research and you love to learn new things.\nYour personal goal + is: You research about math.\nTo give my best complete final answer to the task + respond using 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 complete + as possible, it must be outcome described.\n\nI MUST use these formats, my job + depends on it!"}, {"role": "user", "content": "\nCurrent Task: Research a topic + to teach a kid aged 6 about math.\n\nThis is the expected criteria for your + final answer: A topic, explanation, angle, and examples.\nyou MUST return the + actual complete content as the final answer, not a summary.\n\n# Useful context: + \n\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:"}], "model": "gpt-4o-mini", "stop": + ["\nObservation:"]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '1030' + content-type: + - application/json + cookie: + - __cf_bm=C7ejNhC7vNTBO9VtBqzN_ce__mP2Dz8noDo2lIcNBn0-1744491164-1.0.1.1-kQgWk4d54JIGxg_yCJ.7uV9HkU8JXrhpfIth0WHDdqf9ESzAsQyDu0xKVLYnga.xswBnm5kePpuFCcnIqGKgyag31cEyuiFFf6JHTvQcvWI; + _cfuvid=QuvcyYK0MZfY9dNclglrzesXcplWfoZN.rd4J57.xtY-1744491164641-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BLc8DAj1Tept22jJPnWaYga9UPHGF\",\n \"object\": + \"chat.completion\",\n \"created\": 1744491165,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": \"I now can give a great answer. \\nFinal + Answer: \\n\\n**Topic: Introducing Basic Addition**\\n\\n**Explanation:** \\nAddition + is one of the first fundamental concepts that children learn in math. It involves + combining two or more groups of objects or numbers to find a total. Teaching + addition helps kids understand how to solve everyday problems and builds the + foundation for more advanced math concepts later on.\\n\\n**Angle:** \\nTo + make learning addition fun and engaging for a 6-year-old, we can use colorful + visuals and interactive methods. A playful approach, using everyday objects + they can relate to, will capture their attention and promote better understanding.\\n\\n**Examples:**\\n\\n1. + **Using Objects:** \\n Gather small items like toys, blocks, or fruits. For + instance, take 3 apples and add 2 more apples. Lay them out together and count + them:\\n - Place 3 apples on a table.\\n - Ask, \\\"If I add 2 more apples, + how many do we have now?\\\"\\n - Count all the apples together to show that + 3 + 2 = 5.\\n\\n2. **Story Problems:** \\n Create a simple story that involves + addition. For example:\\n - \\\"You have 4 red balloons, and your friend gives + you 2 blue balloons. How many balloons do you have in total?\\\"\\n - Help + them visualize it by drawing balloons and counting them.\\n\\n3. **Interactive + Games:** \\n Utilize fun games to practice addition. A game like \u201CAddition + Bingo\u201D can be exciting:\\n - Create bingo cards with addition problems + (like 1 + 2, 3 + 1) in each square.\\n - Call out the answers, and when a + child has the problem that matches the answer, they can cover that square.\\n\\n4. + **Visual Aids:** \\n Use a number line to show addition. Draw a number line + from 0 to 10.\\n - Start at 3, and count 2 more jumps forward to reach 5, + explaining what happens when you add numbers on the number line.\\n\\n5. **Songs + and Rhymes:** \\n Incorporate catchy songs or rhymes that involve counting + and adding. For example, \u201CFive Little Ducks\u201D can be a fun way to introduce + subtraction in the context of counting forward.\\n\\nBy using these interactive + methods, children can grasp the concept of addition easily and enjoyably. Allowing + kids to make connections with real-life examples will nurture their love for + math and pave the way for future learning.\",\n \"refusal\": null,\n + \ \"annotations\": []\n },\n \"logprobs\": null,\n \"finish_reason\": + \"stop\"\n }\n ],\n \"usage\": {\n \"prompt_tokens\": 206,\n \"completion_tokens\": + 504,\n \"total_tokens\": 710,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_44added55e\"\n}\n" + headers: + CF-RAY: + - 92f59bf4a822572a-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:52:57 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '12719' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999777' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_82f6b628956f2f524b5a813c2248a92b + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["I now can give a great answer. Final Answer: **Topic: Introducing + Basic Addition** **Explanation:** Addition is one of the first fundamental + concepts that children learn in math. It involves combining two or more groups + of objects or numbers to find a total. Teaching addition helps kids understand + how to solve everyday problems and builds the foundation for more advanced math + concepts later on. **Angle:** To make learning addition fun and engaging + for a 6-year-old, we can use colorful visuals and interactive methods. A playful + approach, using everyday objects they can relate to, will capture their attention + and promote better understanding. **Examples:** 1. **Using Objects:** Gather + small items like toys, blocks, or fruits. For instance, take 3 apples and add + 2 more apples. Lay them out together and count them: - Place 3 apples on + a table. - Ask, \"If I add 2 more apples, how many do we have now?\" - + Count all the apples together to show that 3 + 2 = 5. 2. **Story Problems:** Create + a simple story that involves addition. For example: - \"You have 4 red balloons, + and your friend gives you 2 blue balloons. How many balloons do you have in + total?\" - Help them visualize it by drawing balloons and counting them. 3. + **Interactive Games:** Utilize fun games to practice addition. A game like + \u201cAddition Bingo\u201d can be exciting: - Create bingo cards with addition + problems (like 1 + 2, 3 + 1) in each square. - Call out the answers, and + when a child has the problem that matches the answer, they can cover that square. 4. + **Visual Aids:** Use a number line to show addition. Draw a number line + from 0 to 10. - Start at 3, and count 2 more jumps forward to reach 5, explaining + what happens when you add numbers on the number line. 5. **Songs and Rhymes:** Incorporate + catchy songs or rhymes that involve counting and adding. For example, \u201cFive + Little Ducks\u201d can be a fun way to introduce subtraction in the context + of counting forward. By using these interactive methods, children can grasp + the concept of addition easily and enjoyably. Allowing kids to make connections + with real-life examples will nurture their love for math and pave the way for + future learning."], "model": "text-embedding-3-small", "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '2340' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": + 514,\n \"total_tokens\": 514\n }\n}\n" + headers: + CF-RAY: + - 92f59c45fe8a01a1-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 20:52:58 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=.E5frVsbnouTvYCdMdv6xTsbxIKa0cGfieFpUdzLyFw-1744491178-1.0.1.1-9L_mO4kTLYQcsyPJH8VW8mKZaKxtUNmSQh1M3azRg6otw__XJkbU7PY2qLDoOoikow.Sk_XPc2STfYjPm9pY_m_ZE4j21.j1YLWFBrLRNY4; + path=/; expires=Sat, 12-Apr-25 21:22:58 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=pStEaD_yX5_0Hi8lDwa3XkSIXv1peylcsq05XdbvMg8-1744491178771-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-3-small + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '85' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-cbdb5c968-skgz8 + x-envoy-upstream-service-time: + - '71' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999439' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 3ms + x-request-id: + - req_0dcb8cc2b2d67c7dbe8569da90cf498e + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/cassettes/test_warning_long_term_memory_without_entity_memory.yaml b/tests/cassettes/test_warning_long_term_memory_without_entity_memory.yaml new file mode 100644 index 000000000..35ed051be --- /dev/null +++ b/tests/cassettes/test_warning_long_term_memory_without_entity_memory.yaml @@ -0,0 +1,205 @@ +interactions: +- request: + body: !!binary | + CuAMCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkStwwKEgoQY3Jld2FpLnRl + bGVtZXRyeRKdCAoQE1JYPHUcNy20EEB8E7lQKRIIeom6mAik9I0qDENyZXcgQ3JlYXRlZDABOdhP + ANFPrzUYQWCwCNFPrzUYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGgoOcHl0aG9uX3Zl + cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIGM5N2I1ZmViNWQxYjY2YmI1OTAwNmFhYTAx + YTI5Y2Q2SjEKB2NyZXdfaWQSJgokMjNmZDllZTktMWRiZC00M2FjLTlhZGYtNTQ5YWFhZTNkMTNj + ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3 + X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3 + X2ZpbmdlcnByaW50EiYKJDk2M2UyNDA4LTI3MzktNGU3ZS04ZTAzLTIxOGUzZjhmMTFhZEo7Chtj + cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xMlQxODoyNjoyOC4wMTg1MzVK + 0QIKC2NyZXdfYWdlbnRzEsECCr4CW3sia2V5IjogIjA3ZDk5YjYzMDQxMWQzNWZkOTA0N2E1MzJk + NTNkZGE3IiwgImlkIjogIjA3ZWIyOWYzLWE2OWQtNGQ1MC1iZGJiLTAwNjEzN2UzYjU4MiIsICJy + b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiBmYWxzZSwgIm1heF9pdGVyIjogMjUsICJt + YXhfcnBtIjogbnVsbCwgImZ1bmN0aW9uX2NhbGxpbmdfbGxtIjogIiIsICJsbG0iOiAiZ3B0LTRv + LW1pbmkiLCAiZGVsZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRp + b24/IjogZmFsc2UsICJtYXhfcmV0cnlfbGltaXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX1dSv8B + CgpjcmV3X3Rhc2tzEvABCu0BW3sia2V5IjogIjYzOTk2NTE3ZjNmM2YxYzk0ZDZiYjYxN2FhMGIx + YzRmIiwgImlkIjogImUwOWIzMzg1LThmNTAtNDIxYy1hYzE0LTdhZDU5NTU4YmY4NiIsICJhc3lu + Y19leGVjdXRpb24/IjogZmFsc2UsICJodW1hbl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUi + OiAiUmVzZWFyY2hlciIsICJhZ2VudF9rZXkiOiAiMDdkOTliNjMwNDExZDM1ZmQ5MDQ3YTUzMmQ1 + M2RkYTciLCAidG9vbHNfbmFtZXMiOiBbXX1degIYAYUBAAEAABKABAoQ/KSXqXcsLoGmHCaEWYIa + 9xII/Ucae2PMp18qDFRhc2sgQ3JlYXRlZDABObAfF9FPrzUYQeCUF9FPrzUYSi4KCGNyZXdfa2V5 + EiIKIGM5N2I1ZmViNWQxYjY2YmI1OTAwNmFhYTAxYTI5Y2Q2SjEKB2NyZXdfaWQSJgokMjNmZDll + ZTktMWRiZC00M2FjLTlhZGYtNTQ5YWFhZTNkMTNjSi4KCHRhc2tfa2V5EiIKIDYzOTk2NTE3ZjNm + M2YxYzk0ZDZiYjYxN2FhMGIxYzRmSjEKB3Rhc2tfaWQSJgokZTA5YjMzODUtOGY1MC00MjFjLWFj + MTQtN2FkNTk1NThiZjg2SjoKEGNyZXdfZmluZ2VycHJpbnQSJgokOTYzZTI0MDgtMjczOS00ZTdl + LThlMDMtMjE4ZTNmOGYxMWFkSjoKEHRhc2tfZmluZ2VycHJpbnQSJgokN2FhMTE0NDAtYjNkYi00 + Y2VmLTgzYjUtNTk3ZTMwMTIxZGZhSjsKG3Rhc2tfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoy + MDI1LTA0LTEyVDE4OjI2OjI4LjAxNzMyNEo7ChFhZ2VudF9maW5nZXJwcmludBImCiQ0MDczMjdk + NC1hMzRjLTQyNTUtYWIxYy1iM2I1OTNiMmM4MTJ6AhgBhQEAAQAA + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '1635' + Content-Type: + - application/x-protobuf + User-Agent: + - OTel-OTLP-Exporter-Python/1.31.1 + 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: + - Sat, 12 Apr 2025 21:26:32 GMT + status: + code: 200 + message: OK +- request: + body: '{"messages": [{"role": "system", "content": "You are Researcher. You''re + an expert in research and you love to learn new things.\nYour personal goal + is: You research about math.\nTo give my best complete final answer to the task + respond using 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 complete + as possible, it must be outcome described.\n\nI MUST use these formats, my job + depends on it!"}, {"role": "user", "content": "\nCurrent Task: Research a topic + to teach a kid aged 6 about math.\n\nThis is the expected criteria for your + final answer: A topic, explanation, angle, and examples.\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:"}], "model": "gpt-4o-mini", "stop": ["\nObservation:"]}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate + connection: + - keep-alive + content-length: + - '947' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.68.2 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.68.2 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - '600.0' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + content: "{\n \"id\": \"chatcmpl-BLceqFO97kLaTEPUSKGHkGlckpxLe\",\n \"object\": + \"chat.completion\",\n \"created\": 1744493188,\n \"model\": \"gpt-4o-mini-2024-07-18\",\n + \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": + \"assistant\",\n \"content\": \"I now can give a great answer \\nFinal + Answer: \\n\\n**Topic:** Introduction to Addition\\n\\n**Explanation:** \\nAddition + is a fundamental concept in math that means putting together two or more numbers + to find out how many there are in total. When we add, we combine quantities + to see the total amount we have. The symbol for addition is \\\"+\\\". \\n\\nLet's + break it down so it's easy to understand. If you have a small group of apples + and then you get more apples, to find out how many apples you have altogether, + you add them up! \\n\\n**Angle:** \\nTo teach this concept to a 6-year-old, + we can use tangible objects they can relate to, such as fruits, toys, or stickers. + Kids learn best through play and visual representation, so using real-life examples + will make the concept of addition exciting and engaging!\\n\\n**Examples:** + \ \\n1. **Using Fruits:** \\n - Start with 2 apples. \\n\\n \U0001F34F\U0001F34F + (2 apples)\\n\\n - Then, you receive 3 more apples. \\n\\n \U0001F34F\U0001F34F\U0001F34F + (3 apples)\\n\\n - To find out how many apples you have now, we add them together: + \\n\\n 2 + 3 = 5 \\n\\n - Show them the total by counting all the apples + together: \\n\\n \U0001F34F\U0001F34F\U0001F34F\U0001F34F\U0001F34F (5 apples)\\n\\n2. + **Using Toys:** \\n - Let\u2019s say there are 4 toy cars. \\n\\n \U0001F697\U0001F697\U0001F697\U0001F697 + (4 toy cars)\\n\\n - If you get 2 more toy cars. \\n\\n \U0001F697\U0001F697 + (2 toy cars)\\n\\n - How many do we have in total? \\n\\n 4 + 2 = 6 \\n\\n + \ - Count them all together: \\n\\n \U0001F697\U0001F697\U0001F697\U0001F697\U0001F697\U0001F697 + (6 toy cars)\\n\\n3. **Using Stickers:** \\n - You have 5 stickers. \\n\\n + \ \U0001F31F\U0001F31F\U0001F31F\U0001F31F\U0001F31F (5 stickers)\\n\\n - + Your friend gives you 4 more stickers. \\n\\n \U0001F31F\U0001F31F\U0001F31F\U0001F31F + (4 stickers)\\n\\n - Now, let\u2019s see how many stickers you have in total: + \\n\\n 5 + 4 = 9 \\n\\n - Count them together: \\n\\n \U0001F31F\U0001F31F\U0001F31F\U0001F31F\U0001F31F\U0001F31F\U0001F31F\U0001F31F\U0001F31F + (9 stickers)\\n\\n**Conclusion:** \\nTry to make addition fun! Use snacks or + play time to practice addition. Ask questions during snack time, such as \u201CIf + you eat one of your 5 cookies, how many will you have left?\u201D This approach + makes learning relatable and enjoyable, enhancing their understanding of math + in everyday situations. Happy adding!\",\n \"refusal\": null,\n \"annotations\": + []\n },\n \"logprobs\": null,\n \"finish_reason\": \"stop\"\n + \ }\n ],\n \"usage\": {\n \"prompt_tokens\": 182,\n \"completion_tokens\": + 561,\n \"total_tokens\": 743,\n \"prompt_tokens_details\": {\n \"cached_tokens\": + 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n + \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": + 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": + \"default\",\n \"system_fingerprint\": \"fp_44added55e\"\n}\n" + headers: + CF-RAY: + - 92f5cd5a19257e0f-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 12 Apr 2025 21:26:36 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=RJADJOyAKqFS8232yM1dbM71E3ODRyiAty_s9rGvM0Y-1744493196-1.0.1.1-f4yxtdxM2DD78r7TOvv1J75SF6jkKDecDiDNH3cGysXRR3R.QycZfAzjKzWFkncqaQY4jeqGFYZlVR06qIdq2Gw178QxYpOC6MrJT1eqduw; + path=/; expires=Sat, 12-Apr-25 21:56:36 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=l0OvqELD24_KHHDhiAwih_bsqFrop1327mHak9Y_Ovk-1744493196966-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '8640' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + x-ratelimit-limit-requests: + - '30000' + x-ratelimit-limit-tokens: + - '150000000' + x-ratelimit-remaining-requests: + - '29999' + x-ratelimit-remaining-tokens: + - '149999797' + x-ratelimit-reset-requests: + - 2ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_dda2c2217b856a9012403aeb7378a9e2 + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/cli/test_constants.py b/tests/cli/test_constants.py new file mode 100644 index 000000000..61d8e069b --- /dev/null +++ b/tests/cli/test_constants.py @@ -0,0 +1,23 @@ +import pytest + +from crewai.cli.constants import ENV_VARS, MODELS, PROVIDERS + + +def test_huggingface_in_providers(): + """Test that Huggingface is in the PROVIDERS list.""" + assert "huggingface" in PROVIDERS + + +def test_huggingface_env_vars(): + """Test that Huggingface environment variables are properly configured.""" + assert "huggingface" in ENV_VARS + assert any( + detail.get("key_name") == "HF_TOKEN" + for detail in ENV_VARS["huggingface"] + ) + + +def test_huggingface_models(): + """Test that Huggingface models are properly configured.""" + assert "huggingface" in MODELS + assert len(MODELS["huggingface"]) > 0 diff --git a/tests/conftest.py b/tests/conftest.py index 518c69a81..c0db6316c 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -8,6 +8,7 @@ from dotenv import load_dotenv load_result = load_dotenv(override=True) + @pytest.fixture(autouse=True) def setup_test_environment(): """Set up test environment with a temporary directory for SQLite storage.""" @@ -15,11 +16,13 @@ def setup_test_environment(): # Create the directory with proper permissions storage_dir = Path(temp_dir) / "crewai_test_storage" storage_dir.mkdir(parents=True, exist_ok=True) - + # Validate that the directory was created successfully if not storage_dir.exists() or not storage_dir.is_dir(): - raise RuntimeError(f"Failed to create test storage directory: {storage_dir}") - + raise RuntimeError( + f"Failed to create test storage directory: {storage_dir}" + ) + # Verify directory permissions try: # Try to create a test file to verify write permissions @@ -27,11 +30,20 @@ def setup_test_environment(): test_file.touch() test_file.unlink() except (OSError, IOError) as e: - raise RuntimeError(f"Test storage directory {storage_dir} is not writable: {e}") - + raise RuntimeError( + f"Test storage directory {storage_dir} is not writable: {e}" + ) + # Set environment variable to point to the test storage directory os.environ["CREWAI_STORAGE_DIR"] = str(storage_dir) - + yield - + # Cleanup is handled automatically when tempfile context exits + + +@pytest.fixture(scope="module") +def vcr_config(request) -> dict: + return { + "cassette_library_dir": "tests/cassettes", + } diff --git a/tests/crew_test.py b/tests/crew_test.py index 9a760b19c..1aa087a67 100644 --- a/tests/crew_test.py +++ b/tests/crew_test.py @@ -4,6 +4,7 @@ import hashlib import json import os import sys +import tempfile from concurrent.futures import Future from unittest import mock from unittest.mock import MagicMock, Mock, patch @@ -19,6 +20,8 @@ from crewai.crews.crew_output import CrewOutput from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource from crewai.llm import LLM from crewai.memory.contextual.contextual_memory import ContextualMemory +from crewai.memory.long_term.long_term_memory import LongTermMemory +from crewai.memory.short_term.short_term_memory import ShortTermMemory from crewai.process import Process from crewai.task import Task from crewai.tasks.conditional_task import ConditionalTask @@ -39,11 +42,6 @@ from crewai.utilities.events.event_listener import EventListener from crewai.utilities.rpm_controller import RPMController from crewai.utilities.task_output_storage_handler import TaskOutputStorageHandler -# Skip streaming tests when running in CI/CD environments -skip_streaming_in_ci = pytest.mark.skipif( - os.getenv("CI") is not None, reason="Skipping streaming tests in CI/CD environments" -) - ceo = Agent( role="CEO", goal="Make sure the writers in your company produce amazing content.", @@ -960,7 +958,6 @@ def test_api_calls_throttling(capsys): moveon.assert_called() -@skip_streaming_in_ci @pytest.mark.vcr(filter_headers=["authorization"]) def test_crew_kickoff_usage_metrics(): inputs = [ @@ -996,7 +993,6 @@ def test_crew_kickoff_usage_metrics(): assert result.token_usage.cached_prompt_tokens == 0 -@skip_streaming_in_ci @pytest.mark.vcr(filter_headers=["authorization"]) def test_crew_kickoff_streaming_usage_metrics(): inputs = [ @@ -2404,6 +2400,136 @@ def test_using_contextual_memory(): contextual_mem.assert_called_once() +@pytest.mark.vcr(filter_headers=["authorization"]) +def test_using_contextual_memory_with_long_term_memory(): + from unittest.mock import patch + + math_researcher = Agent( + role="Researcher", + goal="You research about math.", + backstory="You're an expert in research and you love to learn new things.", + allow_delegation=False, + ) + + task1 = Task( + description="Research a topic to teach a kid aged 6 about math.", + expected_output="A topic, explanation, angle, and examples.", + agent=math_researcher, + ) + + crew = Crew( + agents=[math_researcher], + tasks=[task1], + long_term_memory=LongTermMemory(), + ) + + with patch.object(ContextualMemory, "build_context_for_task") as contextual_mem: + crew.kickoff() + contextual_mem.assert_called_once() + assert crew.memory is False + + +@pytest.mark.vcr(filter_headers=["authorization"]) +def test_warning_long_term_memory_without_entity_memory(): + from unittest.mock import patch + + math_researcher = Agent( + role="Researcher", + goal="You research about math.", + backstory="You're an expert in research and you love to learn new things.", + allow_delegation=False, + ) + + task1 = Task( + description="Research a topic to teach a kid aged 6 about math.", + expected_output="A topic, explanation, angle, and examples.", + agent=math_researcher, + ) + + crew = Crew( + agents=[math_researcher], + tasks=[task1], + long_term_memory=LongTermMemory(), + ) + + with ( + patch("crewai.utilities.printer.Printer.print") as mock_print, + patch( + "crewai.memory.long_term.long_term_memory.LongTermMemory.save" + ) as save_memory, + ): + crew.kickoff() + mock_print.assert_called_with( + content="Long term memory is enabled, but entity memory is not enabled. Please configure entity memory or set memory=True to automatically enable it.", + color="bold_yellow", + ) + save_memory.assert_not_called() + + +@pytest.mark.vcr(filter_headers=["authorization"]) +def test_long_term_memory_with_memory_flag(): + from unittest.mock import patch + + math_researcher = Agent( + role="Researcher", + goal="You research about math.", + backstory="You're an expert in research and you love to learn new things.", + allow_delegation=False, + ) + + task1 = Task( + description="Research a topic to teach a kid aged 6 about math.", + expected_output="A topic, explanation, angle, and examples.", + agent=math_researcher, + ) + + crew = Crew( + agents=[math_researcher], + tasks=[task1], + memory=True, + long_term_memory=LongTermMemory(), + ) + + with ( + patch("crewai.utilities.printer.Printer.print") as mock_print, + patch( + "crewai.memory.long_term.long_term_memory.LongTermMemory.save" + ) as save_memory, + ): + crew.kickoff() + mock_print.assert_not_called() + save_memory.assert_called_once() + + +@pytest.mark.vcr(filter_headers=["authorization"]) +def test_using_contextual_memory_with_short_term_memory(): + from unittest.mock import patch + + math_researcher = Agent( + role="Researcher", + goal="You research about math.", + backstory="You're an expert in research and you love to learn new things.", + allow_delegation=False, + ) + + task1 = Task( + description="Research a topic to teach a kid aged 6 about math.", + expected_output="A topic, explanation, angle, and examples.", + agent=math_researcher, + ) + + crew = Crew( + agents=[math_researcher], + tasks=[task1], + short_term_memory=ShortTermMemory(), + ) + + with patch.object(ContextualMemory, "build_context_for_task") as contextual_mem: + crew.kickoff() + contextual_mem.assert_called_once() + assert crew.memory is False + + @pytest.mark.vcr(filter_headers=["authorization"]) def test_disabled_memory_using_contextual_memory(): from unittest.mock import patch @@ -3935,11 +4061,17 @@ def test_crew_guardrail_feedback_in_context(): @pytest.mark.vcr(filter_headers=["authorization"]) def test_before_kickoff_callback(): - from crewai.project import CrewBase, agent, before_kickoff, task + from crewai.project import CrewBase @CrewBase class TestCrewClass: - from crewai.project import crew + from typing import List + + from crewai.agents.agent_builder.base_agent import BaseAgent + from crewai.project import CrewBase, agent, before_kickoff, crew, task + + agents: List[BaseAgent] + tasks: List[Task] agents_config = None tasks_config = None @@ -4115,9 +4247,97 @@ def test_crew_kickoff_for_each_works_with_manager_agent_copy(): assert crew_copy.manager_agent.id != crew.manager_agent.id assert crew_copy.manager_agent.role == crew.manager_agent.role assert crew_copy.manager_agent.goal == crew.manager_agent.goal - assert crew_copy.manager_agent.backstory == crew.manager_agent.backstory - assert isinstance(crew_copy.manager_agent.agent_executor, CrewAgentExecutor) - assert isinstance(crew_copy.manager_agent.cache_handler, CacheHandler) + + +def test_crew_copy_with_memory(): + """Test that copying a crew with memory enabled does not raise validation errors and copies memory correctly.""" + agent = Agent(role="Test Agent", goal="Test Goal", backstory="Test Backstory") + task = Task(description="Test Task", expected_output="Test Output", agent=agent) + crew = Crew(agents=[agent], tasks=[task], memory=True) + + original_short_term_id = ( + id(crew._short_term_memory) if crew._short_term_memory else None + ) + original_long_term_id = ( + id(crew._long_term_memory) if crew._long_term_memory else None + ) + original_entity_id = id(crew._entity_memory) if crew._entity_memory else None + original_external_id = id(crew._external_memory) if crew._external_memory else None + original_user_id = id(crew._user_memory) if crew._user_memory else None + + try: + crew_copy = crew.copy() + + assert hasattr( + crew_copy, "_short_term_memory" + ), "Copied crew should have _short_term_memory" + assert ( + crew_copy._short_term_memory is not None + ), "Copied _short_term_memory should not be None" + assert ( + id(crew_copy._short_term_memory) != original_short_term_id + ), "Copied _short_term_memory should be a new object" + + assert hasattr( + crew_copy, "_long_term_memory" + ), "Copied crew should have _long_term_memory" + assert ( + crew_copy._long_term_memory is not None + ), "Copied _long_term_memory should not be None" + assert ( + id(crew_copy._long_term_memory) != original_long_term_id + ), "Copied _long_term_memory should be a new object" + + assert hasattr( + crew_copy, "_entity_memory" + ), "Copied crew should have _entity_memory" + assert ( + crew_copy._entity_memory is not None + ), "Copied _entity_memory should not be None" + assert ( + id(crew_copy._entity_memory) != original_entity_id + ), "Copied _entity_memory should be a new object" + + if original_external_id: + assert hasattr( + crew_copy, "_external_memory" + ), "Copied crew should have _external_memory" + assert ( + crew_copy._external_memory is not None + ), "Copied _external_memory should not be None" + assert ( + id(crew_copy._external_memory) != original_external_id + ), "Copied _external_memory should be a new object" + else: + assert ( + not hasattr(crew_copy, "_external_memory") + or crew_copy._external_memory is None + ), "Copied _external_memory should be None if not originally present" + + if original_user_id: + assert hasattr( + crew_copy, "_user_memory" + ), "Copied crew should have _user_memory" + assert ( + crew_copy._user_memory is not None + ), "Copied _user_memory should not be None" + assert ( + id(crew_copy._user_memory) != original_user_id + ), "Copied _user_memory should be a new object" + else: + assert ( + not hasattr(crew_copy, "_user_memory") or crew_copy._user_memory is None + ), "Copied _user_memory should be None if not originally present" + + except pydantic_core.ValidationError as e: + if "Input should be an instance of" in str(e) and ("Memory" in str(e)): + pytest.fail( + f"Copying with memory raised Pydantic ValidationError, likely due to incorrect memory copy: {e}" + ) + else: + raise e # Re-raise other validation errors + except Exception as e: + pytest.fail(f"Copying crew raised an unexpected exception: {e}") @patch.dict(os.environ, {}, clear=True) # Ensure AGENTOPS_API_KEY is not set diff --git a/tests/llm_test.py b/tests/llm_test.py index 65cc75bab..2bd03306b 100644 --- a/tests/llm_test.py +++ b/tests/llm_test.py @@ -2,13 +2,16 @@ import os from time import sleep from unittest.mock import MagicMock, patch +import litellm import pytest from pydantic import BaseModel from crewai.agents.agent_builder.utilities.base_token_process import TokenProcess from crewai.llm import CONTEXT_WINDOW_USAGE_RATIO, LLM -from crewai.utilities.events import crewai_event_bus -from crewai.utilities.events.tool_usage_events import ToolExecutionErrorEvent +from crewai.utilities.events import ( + LLMCallCompletedEvent, + LLMStreamChunkEvent, +) from crewai.utilities.token_counter_callback import TokenCalcHandler @@ -304,6 +307,27 @@ def test_context_window_validation(): assert "must be between 1024 and 2097152" in str(excinfo.value) +@pytest.fixture +def get_weather_tool_schema(): + return { + "type": "function", + "function": { + "name": "get_weather", + "description": "Get the current weather in a given location", + "parameters": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "The city and state, e.g. San Francisco, CA", + } + }, + "required": ["location"], + }, + }, + } + + @pytest.mark.vcr(filter_headers=["authorization"]) @pytest.fixture def anthropic_llm(): @@ -395,3 +419,117 @@ def test_deepseek_r1_with_open_router(): result = llm.call("What is the capital of France?") assert isinstance(result, str) assert "Paris" in result + + +def assert_event_count( + mock_emit, + expected_completed_tool_call: int = 0, + expected_stream_chunk: int = 0, + expected_completed_llm_call: int = 0, + expected_final_chunk_result: str = "", +): + event_count = { + "completed_tool_call": 0, + "stream_chunk": 0, + "completed_llm_call": 0, + } + final_chunk_result = "" + for _call in mock_emit.call_args_list: + event = _call[1]["event"] + + if ( + isinstance(event, LLMCallCompletedEvent) + and event.call_type.value == "tool_call" + ): + event_count["completed_tool_call"] += 1 + elif isinstance(event, LLMStreamChunkEvent): + event_count["stream_chunk"] += 1 + final_chunk_result += event.chunk + elif ( + isinstance(event, LLMCallCompletedEvent) + and event.call_type.value == "llm_call" + ): + event_count["completed_llm_call"] += 1 + else: + continue + + assert event_count["completed_tool_call"] == expected_completed_tool_call + assert event_count["stream_chunk"] == expected_stream_chunk + assert event_count["completed_llm_call"] == expected_completed_llm_call + assert final_chunk_result == expected_final_chunk_result + + +@pytest.fixture +def mock_emit() -> MagicMock: + from crewai.utilities.events.crewai_event_bus import CrewAIEventsBus + + with patch.object(CrewAIEventsBus, "emit") as mock_emit: + yield mock_emit + + +@pytest.mark.vcr(filter_headers=["authorization"]) +def test_handle_streaming_tool_calls(get_weather_tool_schema, mock_emit): + llm = LLM(model="openai/gpt-4o", stream=True) + response = llm.call( + messages=[ + {"role": "user", "content": "What is the weather in New York?"}, + ], + tools=[get_weather_tool_schema], + available_functions={ + "get_weather": lambda location: f"The weather in {location} is sunny" + }, + ) + assert response == "The weather in New York, NY is sunny" + + expected_final_chunk_result = ( + '{"location":"New York, NY"}The weather in New York, NY is sunny' + ) + assert_event_count( + mock_emit=mock_emit, + expected_completed_tool_call=1, + expected_stream_chunk=10, + expected_completed_llm_call=1, + expected_final_chunk_result=expected_final_chunk_result, + ) + + +@pytest.mark.vcr(filter_headers=["authorization"]) +def test_handle_streaming_tool_calls_no_available_functions( + get_weather_tool_schema, mock_emit +): + llm = LLM(model="openai/gpt-4o", stream=True) + response = llm.call( + messages=[ + {"role": "user", "content": "What is the weather in New York?"}, + ], + tools=[get_weather_tool_schema], + ) + assert response == "" + + assert_event_count( + mock_emit=mock_emit, + expected_stream_chunk=9, + expected_completed_llm_call=1, + expected_final_chunk_result='{"location":"New York, NY"}', + ) + + +@pytest.mark.vcr(filter_headers=["authorization"]) +def test_handle_streaming_tool_calls_no_tools(mock_emit): + llm = LLM(model="openai/gpt-4o", stream=True) + response = llm.call( + messages=[ + {"role": "user", "content": "What is the weather in New York?"}, + ], + ) + assert ( + response + == "I'm unable to provide real-time information or current weather updates. For the latest weather information in New York, I recommend checking a reliable weather website or app, such as the National Weather Service, Weather.com, or a similar service." + ) + + assert_event_count( + mock_emit=mock_emit, + expected_stream_chunk=46, + expected_completed_llm_call=1, + expected_final_chunk_result=response, + ) diff --git a/tests/memory/cassettes/test_save_and_search_with_provider.yaml b/tests/memory/cassettes/test_save_and_search_with_provider.yaml deleted file mode 100644 index c30f3f065..000000000 --- a/tests/memory/cassettes/test_save_and_search_with_provider.yaml +++ /dev/null @@ -1,270 +0,0 @@ -interactions: -- request: - body: '' - headers: - accept: - - '*/*' - accept-encoding: - - gzip, deflate - connection: - - keep-alive - host: - - api.mem0.ai - user-agent: - - python-httpx/0.27.0 - method: GET - uri: https://api.mem0.ai/v1/memories/?user_id=test - response: - body: - string: '[]' - headers: - CF-Cache-Status: - - DYNAMIC - CF-RAY: - - 8b477138bad847b9-BOM - Connection: - - keep-alive - Content-Length: - - '2' - Content-Type: - - application/json - Date: - - Sat, 17 Aug 2024 06:00:11 GMT - NEL: - - '{"success_fraction":0,"report_to":"cf-nel","max_age":604800}' - Report-To: - - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=uuyH2foMJVDpV%2FH52g1q%2FnvXKe3dBKVzvsK0mqmSNezkiszNR9OgrEJfVqmkX%2FlPFRP2sH4zrOuzGo6k%2FjzsjYJczqSWJUZHN2pPujiwnr1E9W%2BdLGKmG6%2FqPrGYAy2SBRWkkJVWsTO3OQ%3D%3D"}],"group":"cf-nel","max_age":604800}' - Server: - - cloudflare - allow: - - GET, POST, DELETE, OPTIONS - alt-svc: - - h3=":443"; ma=86400 - cross-origin-opener-policy: - - same-origin - referrer-policy: - - same-origin - vary: - - Accept, origin, Cookie - x-content-type-options: - - nosniff - x-frame-options: - - DENY - status: - code: 200 - message: OK -- request: - body: '{"batch": [{"properties": {"python_version": "3.12.4 (v3.12.4:8e8a4baf65, - Jun 6 2024, 17:33:18) [Clang 13.0.0 (clang-1300.0.29.30)]", "os": "darwin", - "os_version": "Darwin Kernel Version 23.4.0: Wed Feb 21 21:44:54 PST 2024; root:xnu-10063.101.15~2/RELEASE_ARM64_T6030", - "os_release": "23.4.0", "processor": "arm", "machine": "arm64", "function": - "mem0.client.main.MemoryClient", "$lib": "posthog-python", "$lib_version": "3.5.0", - "$geoip_disable": true}, "timestamp": "2024-08-17T06:00:11.526640+00:00", "context": - {}, "distinct_id": "fd411bd3-99a2-42d6-acd7-9fca8ad09580", "event": "client.init"}], - "historical_migration": false, "sentAt": "2024-08-17T06:00:11.701621+00:00", - "api_key": "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX"}' - headers: - Accept: - - '*/*' - Accept-Encoding: - - gzip, deflate - Connection: - - keep-alive - Content-Length: - - '740' - Content-Type: - - application/json - User-Agent: - - posthog-python/3.5.0 - method: POST - uri: https://us.i.posthog.com/batch/ - response: - body: - string: '{"status":"Ok"}' - headers: - Connection: - - keep-alive - Content-Length: - - '15' - Content-Type: - - application/json - Date: - - Sat, 17 Aug 2024 06:00:12 GMT - access-control-allow-credentials: - - 'true' - server: - - envoy - vary: - - origin, access-control-request-method, access-control-request-headers - x-envoy-upstream-service-time: - - '69' - status: - code: 200 - message: OK -- request: - body: '{"messages": [{"role": "user", "content": "Remember the following insights - from Agent run: test value with provider"}], "metadata": {"task": "test_task_provider", - "agent": "test_agent_provider"}, "app_id": "Researcher"}' - headers: - accept: - - '*/*' - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '219' - content-type: - - application/json - host: - - api.mem0.ai - user-agent: - - python-httpx/0.27.0 - method: POST - uri: https://api.mem0.ai/v1/memories/ - response: - body: - string: '{"message":"ok"}' - headers: - CF-Cache-Status: - - DYNAMIC - CF-RAY: - - 8b477140282547b9-BOM - Connection: - - keep-alive - Content-Length: - - '16' - Content-Type: - - application/json - Date: - - Sat, 17 Aug 2024 06:00:13 GMT - NEL: - - '{"success_fraction":0,"report_to":"cf-nel","max_age":604800}' - Report-To: - - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=FRjJKSk3YxVj03wA7S05H8ts35KnWfqS3wb6Rfy4kVZ4BgXfw7nJbm92wI6vEv5fWcAcHVnOlkJDggs11B01BMuB2k3a9RqlBi0dJNiMuk%2Bgm5xE%2BODMPWJctYNRwQMjNVbteUpS%2Fad8YA%3D%3D"}],"group":"cf-nel","max_age":604800}' - Server: - - cloudflare - allow: - - GET, POST, DELETE, OPTIONS - alt-svc: - - h3=":443"; ma=86400 - cross-origin-opener-policy: - - same-origin - referrer-policy: - - same-origin - vary: - - Accept, origin, Cookie - x-content-type-options: - - nosniff - x-frame-options: - - DENY - status: - code: 200 - message: OK -- request: - body: '{"query": "test value with provider", "limit": 3, "app_id": "Researcher"}' - headers: - accept: - - '*/*' - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '73' - content-type: - - application/json - host: - - api.mem0.ai - user-agent: - - python-httpx/0.27.0 - method: POST - uri: https://api.mem0.ai/v1/memories/search/ - response: - body: - string: '[]' - headers: - CF-Cache-Status: - - DYNAMIC - CF-RAY: - - 8b47714d083b47b9-BOM - Connection: - - keep-alive - Content-Length: - - '2' - Content-Type: - - application/json - Date: - - Sat, 17 Aug 2024 06:00:14 GMT - NEL: - - '{"success_fraction":0,"report_to":"cf-nel","max_age":604800}' - Report-To: - - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=2DRWL1cdKdMvnE8vx1fPUGeTITOgSGl3N5g84PS6w30GRqpfz79BtSx6REhpnOiFV8kM6KGqln0iCZ5yoHc2jBVVJXhPJhQ5t0uerD9JFnkphjISrJOU1MJjZWneT9PlNABddxvVNCmluA%3D%3D"}],"group":"cf-nel","max_age":604800}' - Server: - - cloudflare - allow: - - POST, OPTIONS - alt-svc: - - h3=":443"; ma=86400 - cross-origin-opener-policy: - - same-origin - referrer-policy: - - same-origin - vary: - - Accept, origin, Cookie - x-content-type-options: - - nosniff - x-frame-options: - - DENY - status: - code: 200 - message: OK -- request: - body: '{"batch": [{"properties": {"python_version": "3.12.4 (v3.12.4:8e8a4baf65, - Jun 6 2024, 17:33:18) [Clang 13.0.0 (clang-1300.0.29.30)]", "os": "darwin", - "os_version": "Darwin Kernel Version 23.4.0: Wed Feb 21 21:44:54 PST 2024; root:xnu-10063.101.15~2/RELEASE_ARM64_T6030", - "os_release": "23.4.0", "processor": "arm", "machine": "arm64", "function": - "mem0.client.main.MemoryClient", "$lib": "posthog-python", "$lib_version": "3.5.0", - "$geoip_disable": true}, "timestamp": "2024-08-17T06:00:13.593952+00:00", "context": - {}, "distinct_id": "fd411bd3-99a2-42d6-acd7-9fca8ad09580", "event": "client.add"}], - "historical_migration": false, "sentAt": "2024-08-17T06:00:13.858277+00:00", - "api_key": "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX"}' - headers: - Accept: - - '*/*' - Accept-Encoding: - - gzip, deflate - Connection: - - keep-alive - Content-Length: - - '739' - Content-Type: - - application/json - User-Agent: - - posthog-python/3.5.0 - method: POST - uri: https://us.i.posthog.com/batch/ - response: - body: - string: '{"status":"Ok"}' - headers: - Connection: - - keep-alive - Content-Length: - - '15' - Content-Type: - - application/json - Date: - - Sat, 17 Aug 2024 06:00:13 GMT - access-control-allow-credentials: - - 'true' - server: - - envoy - vary: - - origin, access-control-request-method, access-control-request-headers - x-envoy-upstream-service-time: - - '33' - status: - code: 200 - message: OK -version: 1 diff --git a/tests/memory/external/cassettes/test_crew_external_memory_save[save].yaml b/tests/memory/external/cassettes/test_crew_external_memory_save[save].yaml deleted file mode 100644 index b58fe1348..000000000 --- a/tests/memory/external/cassettes/test_crew_external_memory_save[save].yaml +++ /dev/null @@ -1,650 +0,0 @@ -interactions: -- request: - body: '{"input": ["Perform a search on specific topics."], "model": "text-embedding-3-small", - "encoding_format": "base64"}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '115' - content-type: - - application/json - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-read-timeout: - - '600' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/embeddings - response: - content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": - \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n - \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": - 7,\n \"total_tokens\": 7\n }\n}\n" - headers: - CF-RAY: - - 929abaf15acd7df9-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:30 GMT - Server: - - cloudflare - Set-Cookie: - - __cf_bm=JcjzeNadYektCKxz.qAt_Iu9W82BXw8zXu9IzahTzL4-1743538230-1.0.1.1-zltiq2Kl.WZlrShHKUBPQrPv0dX2jM_mrIEDEv58Na6s2GSfEgAQbiffMTPHtElo6HoDyJX5g8sjIacSnLyZSswTCjtL4C75K1IK09Or9mo; - path=/; expires=Tue, 01-Apr-25 20:40:30 GMT; domain=.api.openai.com; HttpOnly; - Secure; SameSite=None - - _cfuvid=cqy59cJ9.MxM3ogPzubxDJvueA5vj1ZPlpD5x5e3hdA-1743538230508-0.0.1.1-604800000; - path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-allow-origin: - - '*' - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-model: - - text-embedding-3-small - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '66' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - via: - - envoy-router-7c6fb6444f-cxmk8 - x-envoy-upstream-service-time: - - '32' - x-ratelimit-limit-requests: - - '10000' - x-ratelimit-limit-tokens: - - '10000000' - x-ratelimit-remaining-requests: - - '9999' - x-ratelimit-remaining-tokens: - - '9999991' - x-ratelimit-reset-requests: - - 6ms - x-ratelimit-reset-tokens: - - 0s - x-request-id: - - req_8ec9a4a21a4dda1d560d7002327e9bf5 - http_version: HTTP/1.1 - status_code: 200 -- request: - body: '{"input": ["Perform a search on specific topics."], "model": "text-embedding-3-small", - "encoding_format": "base64"}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '115' - content-type: - - application/json - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-read-timeout: - - '600' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/embeddings - response: - content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": - \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n - \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": - 7,\n \"total_tokens\": 7\n }\n}\n" - headers: - CF-RAY: - - 929abaf509b47deb-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:30 GMT - Server: - - cloudflare - Set-Cookie: - - __cf_bm=xm0wOFZcQAyJrMSiOz3MZOr_g5T3TyUhPvPR4mQpdeA-1743538230-1.0.1.1-kOKoGCRupMuPeKOGl9Uu0Gwt07QZKWJwMBg7JzariAfNaVs.AnqEQ__712GZsReNyqiOzUE0Qeykvt11gEEyFHX9VyyvNJcb6uHADLpyLLI; - path=/; expires=Tue, 01-Apr-25 20:40:30 GMT; domain=.api.openai.com; HttpOnly; - Secure; SameSite=None - - _cfuvid=.x6X1bgu02i.2_qawj3TiVXv0.G8azhdA2QeTcj83tY-1743538230900-0.0.1.1-604800000; - path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-allow-origin: - - '*' - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-model: - - text-embedding-3-small - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '108' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - via: - - envoy-router-8486ff7cdd-dskkc - x-envoy-upstream-service-time: - - '93' - x-ratelimit-limit-requests: - - '10000' - x-ratelimit-limit-tokens: - - '10000000' - x-ratelimit-remaining-requests: - - '9999' - x-ratelimit-remaining-tokens: - - '9999991' - x-ratelimit-reset-requests: - - 6ms - x-ratelimit-reset-tokens: - - 0s - x-request-id: - - req_7570e7930cbf7583a5c482bc9a9829cd - http_version: HTTP/1.1 - status_code: 200 -- request: - body: !!binary | - CtoMCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkSsQwKEgoQY3Jld2FpLnRl - bGVtZXRyeRKXCAoQoIk4ztsSW1VcQBoGyvUEwRII42yueEHaLpkqDENyZXcgQ3JlYXRlZDABOaDB - SlvCSjIYQai+bVvCSjIYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTA4LjBKGgoOcHl0aG9uX3Zl - cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIDA3YTcxNzY4Y2M0YzkzZWFiM2IzMWUzYzhk - MjgzMmM2SjEKB2NyZXdfaWQSJgokMWI2YjUxZGEtMzgxMy00YjI1LTljN2EtOGM1ODkwM2NkMjk1 - ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAUoaChRjcmV3 - X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3 - X2ZpbmdlcnByaW50EiYKJDFjNGQ3MTZhLTA3YjktNDFjNi05NTk0LWI2ZDJmZmJiNDMxZEo7Chtj - cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0wMVQxNzoxMDowMy45NTQwNjRK - ywIKC2NyZXdfYWdlbnRzErsCCrgCW3sia2V5IjogIjAyZGYxM2UzNjcxMmFiZjUxZDIzOGZlZWJh - YjFjYTI2IiwgImlkIjogIjFmNzNlM2ZiLThmMWEtNGVjYy05ZWY0LWMxZjgxMWU3ZGQ1MyIsICJy - b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiB0cnVlLCAibWF4X2l0ZXIiOiAyNSwgIm1h - eF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8i - LCAiZGVsZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRpb24/Ijog - ZmFsc2UsICJtYXhfcmV0cnlfbGltaXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX1dSv8BCgpjcmV3 - X3Rhc2tzEvABCu0BW3sia2V5IjogIjdiNDJkZjNjM2M3NGMyMWM4OTQ4MGUwYzA3MDUzODVmIiwg - ImlkIjogImU0OGY1MDYwLWM5MjYtNGQ3ZC04M2NhLTk4MzQ0ZDU5OGJmMyIsICJhc3luY19leGVj - dXRpb24/IjogZmFsc2UsICJodW1hbl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUiOiAiUmVz - ZWFyY2hlciIsICJhZ2VudF9rZXkiOiAiMDJkZjEzZTM2NzEyYWJmNTFkMjM4ZmVlYmFiMWNhMjYi - LCAidG9vbHNfbmFtZXMiOiBbXX1degIYAYUBAAEAABKABAoQWFKbmOfdsTZ4sp84HAkrQRIIQ5oa - A8zScp4qDFRhc2sgQ3JlYXRlZDABOaiGoFvCSjIYQbBPolvCSjIYSi4KCGNyZXdfa2V5EiIKIDA3 - YTcxNzY4Y2M0YzkzZWFiM2IzMWUzYzhkMjgzMmM2SjEKB2NyZXdfaWQSJgokMWI2YjUxZGEtMzgx - My00YjI1LTljN2EtOGM1ODkwM2NkMjk1Si4KCHRhc2tfa2V5EiIKIDdiNDJkZjNjM2M3NGMyMWM4 - OTQ4MGUwYzA3MDUzODVmSjEKB3Rhc2tfaWQSJgokZTQ4ZjUwNjAtYzkyNi00ZDdkLTgzY2EtOTgz - NDRkNTk4YmYzSjoKEGNyZXdfZmluZ2VycHJpbnQSJgokMWM0ZDcxNmEtMDdiOS00MWM2LTk1OTQt - YjZkMmZmYmI0MzFkSjoKEHRhc2tfZmluZ2VycHJpbnQSJgokNDY1NmIwOTctMDdkMy00Zjg2LWE1 - OTgtYWQ1YmJiN2YwM2JlSjsKG3Rhc2tfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoyMDI1LTA0 - LTAxVDE3OjEwOjAzLjk1MjM3NUo7ChFhZ2VudF9maW5nZXJwcmludBImCiRkNGQyYzEzMy1hNmE4 - LTQ5YjktYTI0OS1iNzcwNDlkZjZlZWV6AhgBhQEAAQAA - headers: - Accept: - - '*/*' - Accept-Encoding: - - gzip, deflate - Connection: - - keep-alive - Content-Length: - - '1629' - Content-Type: - - application/x-protobuf - User-Agent: - - OTel-OTLP-Exporter-Python/1.31.1 - 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, 01 Apr 2025 20:10:32 GMT - status: - code: 200 - message: OK -- request: - body: '{"messages": [{"role": "system", "content": "You are Researcher. You are - a researcher at a leading tech think tank.\nYour personal goal is: Search relevant - data and provide results\nTo give my best complete final answer to the task - respond using 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 complete - as possible, it must be outcome described.\n\nI MUST use these formats, my job - depends on it!"}, {"role": "user", "content": "\nCurrent Task: Perform a search - on specific topics.\n\nThis is the expected criteria for your final answer: - A list of relevant URLs based on the search query.\nyou MUST return the actual - complete content as the final answer, not a summary.\n\n# Useful context: \nExternal - memories:\n\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:"}], "model": - "gpt-4o", "stop": ["\nObservation:"]}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '984' - content-type: - - application/json - cookie: - - __cf_bm=26AntG8LjHgDcgN0MYB7TgUTXmoUsQqg8yChWws9CAE-1743538222-1.0.1.1-jo5QRov4A_6L5CaGwhXx2I2aGHzSN6wvrS5Lt2yDpcV5vfTu3FlroYl2d4LBq.ySrtNMDxGQgpsA6fMg0z4iEOXpD5DT7CrJKWRNr4H7Y_k; - _cfuvid=.HNP7WFC.O40eZMPSJZ4USQu9SYczq5v794aRx34sZg-1743538222787-0.0.1.1-604800000 - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-raw-response: - - 'true' - x-stainless-read-timeout: - - '600.0' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/chat/completions - response: - content: "{\n \"id\": \"chatcmpl-BHcEJeQt9RxZ492mqpQIcZVupQH1c\",\n \"object\": - \"chat.completion\",\n \"created\": 1743538231,\n \"model\": \"gpt-4o-2024-08-06\",\n - \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": - \"assistant\",\n \"content\": \"My current task is to perform a search - on specific topics and return a list of relevant URLs. I don't have access to - external internet tools to fetch live data, but I can guide on how to find information - based on specific search queries.\\n\\n1. Identify the specific topics or keywords - for the search.\\n2. Use a search engine like Google to input these keywords.\\n3. - Look for credible sources, such as academic publications, news outlets, or specialized - websites, that provide relevant and reliable information.\\n4. Compile the URLs - from credible sources that directly relate to your search query.\\n\\nThought: - I now can give a great answer\\nFinal Answer: To obtain a list of relevant URLs, - you would need to perform a live search on a search engine using the specific - keywords related to your topics of interest and collect URLs from credible sources - such as academic journals, government websites, or reputable news outlets.\",\n - \ \"refusal\": null,\n \"annotations\": []\n },\n \"logprobs\": - null,\n \"finish_reason\": \"stop\"\n }\n ],\n \"usage\": {\n \"prompt_tokens\": - 185,\n \"completion_tokens\": 177,\n \"total_tokens\": 362,\n \"prompt_tokens_details\": - {\n \"cached_tokens\": 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": - {\n \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": - 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": - \"default\",\n \"system_fingerprint\": \"fp_898ac29719\"\n}\n" - headers: - CF-RAY: - - 929abaf84c1a7dfa-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:34 GMT - Server: - - cloudflare - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '2937' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - x-ratelimit-limit-requests: - - '50000' - x-ratelimit-limit-tokens: - - '150000000' - x-ratelimit-remaining-requests: - - '49999' - x-ratelimit-remaining-tokens: - - '149999788' - x-ratelimit-reset-requests: - - 1ms - x-ratelimit-reset-tokens: - - 0s - x-request-id: - - req_c8e37cceac4fcca65da1c883d29cd816 - http_version: HTTP/1.1 - status_code: 200 -- request: - body: '{"input": ["My current task is to perform a search on specific topics and - return a list of relevant URLs. I don''t have access to external internet tools - to fetch live data, but I can guide on how to find information based on specific - search queries. 1. Identify the specific topics or keywords for the search. - 2. Use a search engine like Google to input these keywords. 3. Look for credible - sources, such as academic publications, news outlets, or specialized websites, - that provide relevant and reliable information. 4. Compile the URLs from credible - sources that directly relate to your search query. Thought: I now can give - a great answer Final Answer: To obtain a list of relevant URLs, you would need - to perform a live search on a search engine using the specific keywords related - to your topics of interest and collect URLs from credible sources such as academic - journals, government websites, or reputable news outlets."], "model": "text-embedding-3-small", - "encoding_format": "base64"}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '995' - content-type: - - application/json - cookie: - - __cf_bm=JcjzeNadYektCKxz.qAt_Iu9W82BXw8zXu9IzahTzL4-1743538230-1.0.1.1-zltiq2Kl.WZlrShHKUBPQrPv0dX2jM_mrIEDEv58Na6s2GSfEgAQbiffMTPHtElo6HoDyJX5g8sjIacSnLyZSswTCjtL4C75K1IK09Or9mo; - _cfuvid=cqy59cJ9.MxM3ogPzubxDJvueA5vj1ZPlpD5x5e3hdA-1743538230508-0.0.1.1-604800000 - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-read-timeout: - - '600' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/embeddings - response: - content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": - \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n - \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": - 182,\n \"total_tokens\": 182\n }\n}\n" - headers: - CF-RAY: - - 929abb0bee737df9-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:34 GMT - Server: - - cloudflare - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-allow-origin: - - '*' - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-model: - - text-embedding-3-small - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '86' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - via: - - envoy-router-bbb94bf85-txxsl - x-envoy-upstream-service-time: - - '78' - x-ratelimit-limit-requests: - - '10000' - x-ratelimit-limit-tokens: - - '10000000' - x-ratelimit-remaining-requests: - - '9999' - x-ratelimit-remaining-tokens: - - '9999770' - x-ratelimit-reset-requests: - - 6ms - x-ratelimit-reset-tokens: - - 1ms - x-request-id: - - req_7ea6db6200478758c413eeb853e93f15 - http_version: HTTP/1.1 - status_code: 200 -- request: - body: '{"messages": [{"role": "user", "content": "Assess the quality of the task - completed based on the description, expected output, and actual results.\n\nTask - Description:\nPerform a search on specific topics.\n\nExpected Output:\nA list - of relevant URLs based on the search query.\n\nActual Output:\nMy current task - is to perform a search on specific topics and return a list of relevant URLs. - I don''t have access to external internet tools to fetch live data, but I can - guide on how to find information based on specific search queries.\n\n1. Identify - the specific topics or keywords for the search.\n2. Use a search engine like - Google to input these keywords.\n3. Look for credible sources, such as academic - publications, news outlets, or specialized websites, that provide relevant and - reliable information.\n4. Compile the URLs from credible sources that directly - relate to your search query.\n\nThought: I now can give a great answer\nFinal - Answer: To obtain a list of relevant URLs, you would need to perform a live - search on a search engine using the specific keywords related to your topics - of interest and collect URLs from credible sources such as academic journals, - government websites, or reputable news outlets.\n\nPlease provide:\n- Bullet - points suggestions to improve future similar tasks\n- A score from 0 to 10 evaluating - on completion, quality, and overall performance- Entities extracted from the - task output, if any, their type, description, and relationships"}], "model": - "gpt-4o", "tool_choice": {"type": "function", "function": {"name": "TaskEvaluation"}}, - "tools": [{"type": "function", "function": {"name": "TaskEvaluation", "description": - "Correctly extracted `TaskEvaluation` with all the required parameters with - correct types", "parameters": {"$defs": {"Entity": {"properties": {"name": {"description": - "The name of the entity.", "title": "Name", "type": "string"}, "type": {"description": - "The type of the entity.", "title": "Type", "type": "string"}, "description": - {"description": "Description of the entity.", "title": "Description", "type": - "string"}, "relationships": {"description": "Relationships of the entity.", - "items": {"type": "string"}, "title": "Relationships", "type": "array"}}, "required": - ["name", "type", "description", "relationships"], "title": "Entity", "type": - "object"}}, "properties": {"suggestions": {"description": "Suggestions to improve - future similar tasks.", "items": {"type": "string"}, "title": "Suggestions", - "type": "array"}, "quality": {"description": "A score from 0 to 10 evaluating - on completion, quality, and overall performance, all taking into account the - task description, expected output, and the result of the task.", "title": "Quality", - "type": "number"}, "entities": {"description": "Entities extracted from the - task output.", "items": {"$ref": "#/$defs/Entity"}, "title": "Entities", "type": - "array"}}, "required": ["entities", "quality", "suggestions"], "type": "object"}}}]}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '2952' - content-type: - - application/json - cookie: - - __cf_bm=26AntG8LjHgDcgN0MYB7TgUTXmoUsQqg8yChWws9CAE-1743538222-1.0.1.1-jo5QRov4A_6L5CaGwhXx2I2aGHzSN6wvrS5Lt2yDpcV5vfTu3FlroYl2d4LBq.ySrtNMDxGQgpsA6fMg0z4iEOXpD5DT7CrJKWRNr4H7Y_k; - _cfuvid=.HNP7WFC.O40eZMPSJZ4USQu9SYczq5v794aRx34sZg-1743538222787-0.0.1.1-604800000 - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-raw-response: - - 'true' - x-stainless-read-timeout: - - '600.0' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/chat/completions - response: - content: "{\n \"id\": \"chatcmpl-BHcEMcdhPRL3gLo2olJ4aUutrNfLv\",\n \"object\": - \"chat.completion\",\n \"created\": 1743538234,\n \"model\": \"gpt-4o-2024-08-06\",\n - \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": - \"assistant\",\n \"content\": null,\n \"tool_calls\": [\n {\n - \ \"id\": \"call_rzy02tsLLurMdGuEiul9lHF8\",\n \"type\": - \"function\",\n \"function\": {\n \"name\": \"TaskEvaluation\",\n - \ \"arguments\": \"{\\\"suggestions\\\":[\\\"Ensure access to the - internet or appropriate APIs to perform live searches in future tasks.\\\",\\\"Consider - simulating a response with example URLs if live search capability is unavailable.\\\",\\\"Provide - a disclaimer regarding the unavailability of live data retrieval.\\\",\\\"Indicate - clearly that the task cannot be completed as expected due to limitations.\\\"],\\\"quality\\\":3,\\\"entities\\\":[]}\"\n - \ }\n }\n ],\n \"refusal\": null,\n \"annotations\": - []\n },\n \"logprobs\": null,\n \"finish_reason\": \"stop\"\n - \ }\n ],\n \"usage\": {\n \"prompt_tokens\": 459,\n \"completion_tokens\": - 71,\n \"total_tokens\": 530,\n \"prompt_tokens_details\": {\n \"cached_tokens\": - 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n - \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": - 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": - \"default\",\n \"system_fingerprint\": \"fp_898ac29719\"\n}\n" - headers: - CF-RAY: - - 929abb0f2d587dfa-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:36 GMT - Server: - - cloudflare - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '1657' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - x-ratelimit-limit-requests: - - '50000' - x-ratelimit-limit-tokens: - - '150000000' - x-ratelimit-remaining-requests: - - '49999' - x-ratelimit-remaining-tokens: - - '149999644' - x-ratelimit-reset-requests: - - 1ms - x-ratelimit-reset-tokens: - - 0s - x-request-id: - - req_ff90eb4514605cbdd86933a230691b6b - http_version: HTTP/1.1 - status_code: 200 -version: 1 diff --git a/tests/memory/external/cassettes/test_crew_external_memory_save[search].yaml b/tests/memory/external/cassettes/test_crew_external_memory_save[search].yaml deleted file mode 100644 index 488bd5022..000000000 --- a/tests/memory/external/cassettes/test_crew_external_memory_save[search].yaml +++ /dev/null @@ -1,836 +0,0 @@ -interactions: -- request: - body: '{"input": ["Perform a search on specific topics."], "model": "text-embedding-3-small", - "encoding_format": "base64"}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '115' - content-type: - - application/json - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-read-timeout: - - '600' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/embeddings - response: - content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": - \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n - \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": - 7,\n \"total_tokens\": 7\n }\n}\n" - headers: - CF-RAY: - - 929abab459817e07-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:20 GMT - Server: - - cloudflare - Set-Cookie: - - __cf_bm=wQNqc3BNcaCzhFR4owoCJRMIvs7PWqvy7xmWaIr4k.A-1743538220-1.0.1.1-AIxSGyU_kRiSsc4DYqsunqMwAlAn0fhT.P.7_bBBWTyHeVrexxOSRpm5yj6QmiIVcYwEgdJqk9EsHBy9LfadhgMJ5w8LIrHF_sxBFAXOOxc; - path=/; expires=Tue, 01-Apr-25 20:40:20 GMT; domain=.api.openai.com; HttpOnly; - Secure; SameSite=None - - _cfuvid=g5w7.LJsKZSYhPzW6M1n.OyrMWQSUF5zX.cFK1vZrQI-1743538220809-0.0.1.1-604800000; - path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-allow-origin: - - '*' - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-model: - - text-embedding-3-small - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '308' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - via: - - envoy-router-68459c4c98-bfmcm - x-envoy-upstream-service-time: - - '243' - x-ratelimit-limit-requests: - - '10000' - x-ratelimit-limit-tokens: - - '10000000' - x-ratelimit-remaining-requests: - - '9999' - x-ratelimit-remaining-tokens: - - '9999991' - x-ratelimit-reset-requests: - - 6ms - x-ratelimit-reset-tokens: - - 0s - x-request-id: - - req_51cfe3e45d22af953af55f6708e77623 - http_version: HTTP/1.1 - status_code: 200 -- request: - body: '{"input": ["Perform a search on specific topics."], "model": "text-embedding-3-small", - "encoding_format": "base64"}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '115' - content-type: - - application/json - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-read-timeout: - - '600' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/embeddings - response: - content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": - \"embedding\",\n \"index\": 0,\n \"embedding\": \"6lr3O9X5arxcDzA82U7nvC7Fcr0jUrE7JAA5vQBSTj3yNxg9fhYmPQf8xrtBBKu8zZDAvCGrvDyFNOs8JMb9OoEIgLzkNR89dGKWPXO0Dj2dh1E9DK1SvJMlOrymdZw8sXQRvd2LprwG6xw9g3U5PbAprDwf7Iq6gt/uPGV42rzZTme9leRrvKzUL7z+khy7OMTnuyz1FjxTvkK8MPgaOz2eBDusmvQ7/uSUPInDIjxqKWa9X7Ykvaw3Ur0f7Aq9axEpPajRqzw1RoQ9FkmlvAyt0rx+eci7SHRoPYFrojxuZqW9yZ7mu8U4QD0T9Cg9BuscvNcsk7xoBxI9WAysuoeQ+rz5Cni82pnMvFXIWTxMFEo8ZXhaPXIv7rsZUzy8vislPfT2ybxPzOg8q3igvD5dNj0vSpM7NUaEvWgwebwZ8Jk9lnq2PLl6mbxyBoc8hrkLvQDvqzzJjTy9SW1VPF5rP7w6vVS9pvB7vVYTv7uEhuM4iYlnvCgDPT2z4Uq8RPaEPD+omzuaMtW8YXXWPfRZ7Lsd8x28u3OGPKMgoLxztA49FqzHPF4IHbyV5Os87a/zvGjNVr1QenC9PZ4EvV9TgjwZU7w8JMZ9vKjRKzyvQem82U7nvPiWK7x/1dc8V/uBvb7x6TtMsae8dXPAu2yFdTynhka85alrO3KB5rzrQjq84+o5vdJ7Bz1BBKu6XggdPYZ/UL3a0we9v3aKvJEsTb1xDRq8SK4jvUT2BLzHzgo8QcpvPCmxxLvg4KI9cszLvPj5Tb3L+nW8YK8RvDLxBz3hQ0W8uPX4vNPvU73P7E+9PBnkPDT7njsXlIo7/90BuncJC7zsnkm9MvEHvLwhDrxb/oU8GVO8OwVm/DkV7ZU8bbgdumyF9buazzI7w5FLvQjkCbwyVCq7b9pxvEwUSj0cqDi7fS5jPLqLQzw9ngS8vzzPPCYKUL3Ah7Q7wkbmvM3z4jx+ivK8dr6lvHSLfbx4GjW9VKaFPPiFgbzGIAO9qz7lu4Lf7rgrRw89K3B2PSwGQT3fStg8TV+vvFmAeLxHAJy8xIq4O9WWyDzPJos8Qk+QPDD4GjzeOS49zniDu2fU6TwmXEg80t4pPUob3bwuYlC9otU6PT4SUTwb+rA8DBD1PLDvcL06vVS8JAA5vYN1OTtYDCw7G13TuwZOP7y3Nse86YMIPQruID0UPw49iYlnPXN60zwRXt68v59xPIU0azwPjoI9T6MBPTlJCD1RYjM8tzZHPeyeybzuNBS9D7dpvQZOvzsA7yu9RhhZvVv+hb3VM6Y70OW8u9klAD1LAyC8ClFDORuXDr12viU9qi27O6/eRjy7c4Y7HbliPH/V17yJJkU9RB9svZhzI71s0Nq86eaqvNCCmrzd7kg7IQ7fPJYXFDw0wWO960K6vdWWyLxgr5G8i805PPKaurze1os7VQKVvGCvkTzIfJI9ch5EvTgW4Lyi1bq78omQu8Dq1jy306Q8zyYLvQiqzrwWD2q7JMZ9vHwdOTsrRw89tzbHPKHczTvEUP28aRi8PEq4OjtISwE7DZWVvE5wWTyqLbu8GAhXOwOWIDxrrgY9Z9Tpu1KtGDve//I8BaA3PPs9oLyn6Wg9q3ggvL88zzyklGw8bCJTvBZJJb3QSN88NakmvKYqtzyb4Fy6A5agPPugwrx5dsS85twTvSBIGj3o/mc9r95Gu3MXMb1R/xA9Aq7dvKxxDT0nG3o7eLeSPLzn0jq9Mji8VbevusojhzzHzoq8JUseO4VuJrvlqWu9L621vJEsTb3i2Q+9IgfMO8+aVz3xoc28VWU3vOPquTy306S8nYfRu0+7Pr2kzic8SfmIPI+/E7wrcHa7LVEmvRUWfTxRYrM72tMHvPHbiLyreCC8Qw7COlkdVr212rc8WxbDOyTGfTokxv07M3Z+PPEE8LwanqE8KpkHvPKJED0oZt+7iWAAO/8G6bz0MAU9sdezu0fG4DwfFfK7zzc1PPBW6DwknRa9y5dTPQNEqLy2JZ08eOB5PMfOij1yL+47+DOJvcme5rzyNxi9JMZ9PHi3Ej28SvW7+o8YvMXVnbxKVZg8xoOlvPryury+K6U8MQnFu1Ua0rsmCtC7iQ4IPfSTpzwC6Bg8ezX2OyBImrzR9uY8b3dPvQDvKzzS3im860K6PMnYobyicpg8nepzPDRewbtmYB28ch5EvCBImjx6Xgc9yoYpvarKmLzGgyU9TqqUPZfFGz01qaa7k+t+PAlY1jsZtl47mmyQPKqQXbxAViM9/IiFPUQf7LzPiS09BT2VvO40lLxBZ0089JMnvF986bwiQQe9PFOfvaV8r7sUPw49PZ4EPR1WQD3yYP+85alrPBpkZjwt7gM8n4A+vNPvU7xIEUY8WYD4N+ftvTzRMKK89FlsO55vlL3PJgs8BaC3vHvS0zuFNGu8+z0gu4J8TDw1b+s8MgIyPAxKMD1aaDs9aM1WPKXfUTx7bzE9zqHqvPgziTykzic8nSQvPCpfTLyvQek8sjNDPAmjOzzJnmY8WYB4PC9KEz0j7w48Aks7vIHORL2qkF299lJZPD6vrrz4lis9U77CPPZSWTwwW709k8IXvSPvDj20j9I8pM4nPHpeh72qkN08xFB9PNJ7h7yr20K8uXoZvR4ESL3wkKO8PZ4EPQdf6bzLNDG9jSlJuygDvbzoOCM9T7s+PIXRyDv5Cvg8tXcVu5eLYDrx2wg9Ff6/vKyJyrw1b+u8PZ6EvB254jwWD+q7D1RHvfL93DuPIja8Z7ysuvgziTwj7w67VAkovHDCtLxVZTc85eOmvIVuJjweBEi9WgWZvCYK0Lz+9T680TCiuucFezwWD+q7fbMDvfiWK71ozVa9VcjZPCFZxLyUcJ+8b9pxvFck6Txl23w89oyUOyIHzDzP1JK8lbuEOzBbvTvVhZ48+Ogjvat4ID3O2yW9HVZAPDOwOTwxQ4A8ezV2uyxp47yfHZy9BT2VPFMhZTww+Jo8E7rtu5W7hDwyVKq7CfUzO7PhSrpb/gU7nHanO38PE7zO26W8EZgZOoofMr3y7LK8GGv5PFthqLz/o0Y8zS2euw/xpLwlrsC6yHwSvXgaNby+jse7rJr0PAGdM7uw7/C8b3dPvTRewTn+R7c87NgEPdtHVL0u/608wOpWPFVlNzzyiRC88omQuSpfzLro1YA7nBMFvfEE8Dv8iIW8siIZPeNN3LpygeY7ezV2ufzrJzwTum08j7+TO+2GjLzj6jk9ZsO/OtjaGr1RxVU7HxVyvdsvF7zqMZA8KpmHvJXk67wECu28sO/wPDT7nry8IQ49RwCcvGUVuLx+FiY9m+DcPINkj7wfFfI7FVA4vUnQdzzsOyc82+Sxu+ftPT2RLE091YWevMWbYrxWE7889rX7PHaE6rx0xbi7qG6JO9Sd2zwso548Or1UPIa5i7xODbc7W8RKPPQwhTsvShO70qRuvLtzBjtgZCy7MgKyOidVNTxlshU78T4rut45rjsSRiG7AZ2zvODgIr3+R7c81ywTu1awHD1uyUe7AFJOvSH2IbzF1R09LbTIO/RZ7DyYEAG8pM4nPb59nb309sk8JUueO4ULBDy7cwY9hTRrPPAtAT3bgY+8/6PGPNdVejxi0WW8HmdqPCb5pbydwYy8yiMHPf8G6Ty6KKG7stCgPDhQmzxlspW7B/xGOzN2frxYqQk8YtHlu/lEMzx8upa8G6/LvN0oBLwyt8y7vIQwvcx/ljyylmW70EhfPA88iryQuAC8kSxNvIa5Cz2DEhc9P27gPNrTh7yo0au8hW6mvNzdHr1Ge/s8BuucvBZJpTyiON08ZAQOveWABD23Nse8pti+Op41WTwrcHa8iHi9vBJGIby/dgq9BFXSvFck6TprdMu7X3zpuzdoWDzXVXo8CUCZPGF1Vrut5dm8uXqZPLXaN70W5gK8pDFKPFB68Lyb4Nw8bNDaPKcjJLz0MAW9/qrZutklAL1J0Pc8leRrvM/UEjne1os8dMW4vDa6UDz+qtk6myvCu2m1GT0xQwC9LsVyvMU4wLu26+E8dluDO5TTQTvYoN88fcvAvGAqcTyTwpc8MxNcO3VzQLzxBPC8vsgCvKY74bwxpqI7reXZvEnQdzznUOA8LVGmPKyJyjzk++M8TfwMPbfTJLydwQw9+EtGvC7F8jz1pNE8bgODvCb5Jbwhqzw9Pq+uPJB+Rb0SqUO8grYHvOjVALzyT9W8tI9SPBQ/DrwqX8y8mNbFO/XejLzRk0S911X6vNLeKT3qMZC847B+u4zeYzu1Pdo7GEISPaRrhbyRLE26mHMjPYZ/0LwfTy28vuA/PK7NnDyTwpc8/6NGPCigGr1NXy+92+QxvN0oBDw2ulC8YxxLvDj+Ij3gfQC970W+vHFwvLxJv008dMW4PGAqcbweoaW6BrHhvH2zAzt4ZZo8edlmO5rPMjw8GeS7JJ0WPL+fcby2iD+8k+t+PEfG4DwD4QU8aDB5PERZpzszsLk7FKKwPET2BL2h3M084abnPJm+CD29zxW9IVnEPA5DHTx6wSk9VbcvPEWkDLwknZa7woAhvTKfD72VL1G8xuZHu8nYITw3aNg8zze1vOcF+7z9X/S8OiD3OuaiWDwYQhI89FlsvNZEULoR+zu5/ZkvPWXb/DzJjby83v9yu9/ntbx+YYs8Pws+vKzDBT1tuJ0886tkvNDlPDycE4W8NleuvB4+AzwFPRW7qDROvIYcLr0E8i89QhVVvbndOz0knZY8IP00vGCvkTxVVA08sjPDu8SKuDsZtl479FlsvEIV1bvuNJS8uMwRvVzV9Lz+WGG8LVEmPbtzBjwu/y09B1/pOoK2Bz1NJXQ80IIavX/V17wPjgI8XHLSPNH25ju+8Wk82y8XvPiWK7wZ8Bk8BPKvvE+jAbyVL9E8HEWWvA8CT7xwwrS8lYFJPMcxrTxyL+67wy6pO1Ur/DzG5se8QPOAvevfFz2GuYs7I1IxPX8PEz0FZvw6h5D6PLApLDyiOF27DEowPBH7uzzaNio9eOB5PMQnFr1i0eW7lWmMvCz1lry7c4Y8NvQLvbjMkTwYa/k7RFknO4C9Grwu/607vZVaOlNbIDyQ4Wc82SWAO9v12zxLZkI9Mp+POwQKbTwAjAk9TV8vuSO107uV5Ou79zocPe40lLx11mI9dGKWO2gweT0W5oI6hy1YPTog9zzCRua8dGIWvc+a1zqxdJG8FuYCvQ8CT7yFNOs8s+HKPE0l9Dy1oHy8Dfi3PFipibyIeL08/ZkvPPhLxjsAtXC8YRI0PV29N71ibsO8lno2vFgMLDsCrt28YguhvGy/ML0FoDc8BI8NPOGOqjzTjLG6hn9QvJXkazyPIja9Xmu/OVLW/zyPIja9VAkoPS20yLzLNLG8Xs7hPJgQgTxAHOi8crshPJDhZ7xLAyA9cXC8vI8z4LyIeL071/JXO/5Ht7xbsyA9i2qXPILf7rwMSjA83EDBvD9u4DsnG3o8SfkIPeKf1Lr86yc8HfOdvE1fL71IS4E7stCgPIx7wbwtUaY8v3aKPDC+XzybjmQ7iHi9vClOorxbsyA8XKwNO53BDD3xBPA71dCDPFLW/zqzfii9T6OBO7N+KDuXxRs9Le6DOnkTorue0rY8z5rXPKBoAT2Jcaq8JGPbvMZJ6rxpe148R2O+PBQ/Drzthoy8j9A9PJcovrwnG3o7RWrRPN3uyLzxPis8OQ9NveeKG7y5ehm8vkNivJ8dnDzD3DA8oSczvSYKUD0rR4887a9zPHQo27uYcyO9B1/pvAwQ9TvbgQ+9V14kvIEIAL346KO7OGHFu4Z/0LyEwB68FAXTurN+KLvsU2S7g8cxPH8PE702utA88QTwOjpasjrsOyc99lJZvNKkbryOEYy8J7jXvDC+3zsOQx29iuV2PPCQozyy0CA90TAiPFIQO71GtTY8QBzoOx4+AzwYpTQ8WYB4u0Kysrtgr5G74VTvupQ25Lxgx868s34oPPyIBT0dVsC73Ysmu1uzoLxRxdW8RQevvHs19rxmYJ07d2ytvEm/zTzAh7Q81uEtvJwThTwK7qC8HKg4vfI3mLzWfgu89d4MvY+/kzy262E85JhBPFvEyjykMUo9jWOEPKV8rz0PPAo9lHAfvSZcyDugFgm9m306uxv6ML212re88PNFu8cxrTwPPAq8R2M+PJHJKruo0as7u9YovBm2Xrudh1E7MUOAPCJqbjzT79O8GVM8PCr8KTt3CQs9kBujPMuX0zzM4rg7LKMePfXeDLz+R7e8doTqPKSU7Dsu/y29jtfQvPhLxjt6JMy8CzkGPOLZD7wmp626kY/vuoq8Dz2C3247qDROua/eRjzVlsg6VKYFO9uBjzx7DI88w5HLPEAc6DtAVqO8/wbpvEn5CD1mq4K7N2hYO38Pk7tjVoY7N6KTvJcoPrzyYH88zS0eu6F5K7xshfU8YGSsvBuXDjwuxfI8RwAcvXTFuDuS2tS7BrFhvAE6EbyJJkW9YK+ROALomDx3z8+89JMnPddVejxJbVU8qUV4PNOMsTzE7Vq8UnNdulUr/Dyd6nM89owUPK7NnLuQfkW7UtZ/vFZ24bsQsFY6uznLO2N/7byNKck8rCYoPY+/kz2859K726p2PJC4gLv7A+W8IP00PUDzALzEUH28tiWdu+Q1H720j9I8FRb9vJ412TzbqvY7JRHjOr92Cr09Aae6sjNDPPE+K7z54RC7TqoUvcmeZjprrgY9Fe2VvFYTPzsoZt+86UnNvHh91zuzfqg8fmELvKfp6DujICC86lr3u9J7Bzvx2wi8Xmu/O4U06zzd7si7bAqWPLXat7pyzMs8eBq1PEGhCDzHMS09jHvBO+Y/Nj0J9TO9izDcO31oHrwknZa8HEWWu1f7Abyx1zM8leRrPHKB5rsunIu8Dfg3veFDRb1D/Ze84H2APOpadzzWRFA9Tg23PMN5Dr2ZIas72/VbuxgI1zwvEFg8yoapPLiBLLzwLYE8xzEtPUsDILwvEFg7ncEMPUBWI7yy0CA9YXXWu8RQ/Tp70lO81ZbIvAucqLyZhE08lS9RvBuvSzyJDog6pvB7PAiqzrwmXEi8QyZ/vN7/cju+jsc54PjfvD4SUT17DI+7BKdKPTICMjxptZm8Mp8PvWABCj08U5+70TCiPCZcyDuHyjW8MUOAPBxFlrxZV5E85UZJPOaRrrvV0IM7diHIOxxFFr37oMI8zniDOyVLHj1wXxI6t9OkPFXI2Tzy/dw8vEp1PDog9zxQevC8kyW6vES8yTx9swM825K5vPjoozufHRy6KbHEOBBNNDyhitW8axGpvEMm/7z4S8a8pRmNPNqZTDuwKSw8uu7luwpRwzxEvEm7Owg6vFVUDTybyJ+8yunLvOjVALsaAcS814+1PCUR4zzy/dy6c3rTvHLMS7saniE8cMK0PHkTojy/dgq9rR+VOrfTpLwEjw28uMyRO3AlV7wkxn28uu7lOpC4gDnlgIS6wuPDPN3uyLtSrZg6L0qTvAZOv7w6WrI8WAwsPTj+IjzP1JI8SK6jvDulFzzIfBK8XKwNPY50rjwzTRc8mb4IPOOwfruobgk8T2nGvJZ6tjxUz+w72evEOwxKMLloB5K8yKV5u1sWw7ySdzI8Zdt8PGZxx7sM5w08Sb9NvBJGIT1GUhS6BWZ8PD+oGz2ebxS99u+2PNZ+C7z3Ohy954obvX0u47zPT/K8hNjbO2uuBrybfbq8ULQrPfQwhbxTvsK8Xs7hu58dnDwmRIs8ZmCdu0WkjDshDl84dluDvDRewbysmvS8JUueOsWbYj1nWQo8d2wtPKUZjbyKglS83v9yPBSisDwsBkE7L0qTvLN+KD29lVo8F5SKvFQJqLzyNxg8sxsGvR/sCj0iQQc9wuNDOkJPED1bFkO8VGxKPADvKz0KUUO8s0TtvNCCGjxztI68SEuBvLgeCrxpGDw8amOhuwhHrLtODbc8FRb9PAVmfLziPLI8E5GGPHpehzz/Buk7mHOjPEPD3Lzbkjk9rJp0PBbmAjzD3LC75wX7O5hzIzy/doo87I2fPOOw/jw69w+8B5mkvFm6Mzw6vVS9gCA9ObTJjT1UbEq7ALXwPIEIgDwlEWO8TE4FvVthqDsMrVK8YK8RPTN2frz/QCS9uXoZPMeUT7y1Pdo8mxoYvBQ/Dr1TvsK7kSzNPDZXLjxHxuC8\"\n - \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": - 7,\n \"total_tokens\": 7\n }\n}\n" - headers: - CF-RAY: - - 929abab86d4a7e1b-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:21 GMT - Server: - - cloudflare - Set-Cookie: - - __cf_bm=MCDkRAmvHC26iz7BEoKzXwq4j5v_FEX5IQepnW5ARp4-1743538221-1.0.1.1-GXJkwk8HCFy9W0tA9R.s3NWzCNJ7wCiaUFu4YCbra4nQNVJa_mN3jdnmfREeET4QfWbYGCQXuM5GHffwtQZ_W1EV3mUC4JFa3w5CCDqO41Y; - path=/; expires=Tue, 01-Apr-25 20:40:21 GMT; domain=.api.openai.com; HttpOnly; - Secure; SameSite=None - - _cfuvid=mRF3.ZghYObsvTKqmSfcqSbJFV0SBPVk2Psc.9DVGlE-1743538221434-0.0.1.1-604800000; - path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-allow-origin: - - '*' - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-model: - - text-embedding-3-small - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '156' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - via: - - envoy-router-7c6fb6444f-m8b65 - x-envoy-upstream-service-time: - - '132' - x-ratelimit-limit-requests: - - '10000' - x-ratelimit-limit-tokens: - - '10000000' - x-ratelimit-remaining-requests: - - '9999' - x-ratelimit-remaining-tokens: - - '9999991' - x-ratelimit-reset-requests: - - 6ms - x-ratelimit-reset-tokens: - - 0s - x-request-id: - - req_463b788a4cc327763e9544976b2fe7ce - http_version: HTTP/1.1 - status_code: 200 -- request: - body: !!binary | - CtoMCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkSsQwKEgoQY3Jld2FpLnRl - bGVtZXRyeRKXCAoQllrSJs4siWPoysCAkdyzdhIIeP9LvWGg1D0qDENyZXcgQ3JlYXRlZDABOeAu - xRLASjIYQUh77RLASjIYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTA4LjBKGgoOcHl0aG9uX3Zl - cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIDA3YTcxNzY4Y2M0YzkzZWFiM2IzMWUzYzhk - MjgzMmM2SjEKB2NyZXdfaWQSJgokOWUwNDE3NDgtZTg2MS00M2YzLWE4ZTYtMTA4N2I3NjA1MTE1 - ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAUoaChRjcmV3 - X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3 - X2ZpbmdlcnByaW50EiYKJDlhODQwMjI3LTQwY2UtNDU4OC1iYTAzLTBlYzZlMjQzMDdjMUo7Chtj - cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0wMVQxNzowOTo1NC4xMzIwMzlK - ywIKC2NyZXdfYWdlbnRzErsCCrgCW3sia2V5IjogIjAyZGYxM2UzNjcxMmFiZjUxZDIzOGZlZWJh - YjFjYTI2IiwgImlkIjogImNlMjE2ZTU4LTY1MDgtNDQ0My1iZTY0LWUwNzVhNTQ5YzMzZCIsICJy - b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiB0cnVlLCAibWF4X2l0ZXIiOiAyNSwgIm1h - eF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8i - LCAiZGVsZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRpb24/Ijog - ZmFsc2UsICJtYXhfcmV0cnlfbGltaXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX1dSv8BCgpjcmV3 - X3Rhc2tzEvABCu0BW3sia2V5IjogIjdiNDJkZjNjM2M3NGMyMWM4OTQ4MGUwYzA3MDUzODVmIiwg - ImlkIjogImVmMDNjMDliLTIwNGQtNGU2Yy04NDIwLTQyNmNmOWM4OGFmYyIsICJhc3luY19leGVj - dXRpb24/IjogZmFsc2UsICJodW1hbl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUiOiAiUmVz - ZWFyY2hlciIsICJhZ2VudF9rZXkiOiAiMDJkZjEzZTM2NzEyYWJmNTFkMjM4ZmVlYmFiMWNhMjYi - LCAidG9vbHNfbmFtZXMiOiBbXX1degIYAYUBAAEAABKABAoQZo4JZzOQlEm7ZP/lMPxN9hIIymaC - IpHXF4cqDFRhc2sgQ3JlYXRlZDABObhUIRPASjIYQQgSIxPASjIYSi4KCGNyZXdfa2V5EiIKIDA3 - YTcxNzY4Y2M0YzkzZWFiM2IzMWUzYzhkMjgzMmM2SjEKB2NyZXdfaWQSJgokOWUwNDE3NDgtZTg2 - MS00M2YzLWE4ZTYtMTA4N2I3NjA1MTE1Si4KCHRhc2tfa2V5EiIKIDdiNDJkZjNjM2M3NGMyMWM4 - OTQ4MGUwYzA3MDUzODVmSjEKB3Rhc2tfaWQSJgokZWYwM2MwOWItMjA0ZC00ZTZjLTg0MjAtNDI2 - Y2Y5Yzg4YWZjSjoKEGNyZXdfZmluZ2VycHJpbnQSJgokOWE4NDAyMjctNDBjZS00NTg4LWJhMDMt - MGVjNmUyNDMwN2MxSjoKEHRhc2tfZmluZ2VycHJpbnQSJgokNzcwMDBjZjktZjVlNC00MDJhLTg1 - MTgtNzFhMzZhZTc2MmQwSjsKG3Rhc2tfZmluZ2VycHJpbnRfY3JlYXRlZF9hdBIcChoyMDI1LTA0 - LTAxVDE3OjA5OjU0LjEzMTE4NUo7ChFhZ2VudF9maW5nZXJwcmludBImCiQ0Y2Y4OTc4Yy1iN2M4 - LTRiMjUtODYxMC1lNWE4NmMxOTYwNzB6AhgBhQEAAQAA - headers: - Accept: - - '*/*' - Accept-Encoding: - - gzip, deflate - Connection: - - keep-alive - Content-Length: - - '1629' - Content-Type: - - application/x-protobuf - User-Agent: - - OTel-OTLP-Exporter-Python/1.31.1 - 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, 01 Apr 2025 20:10:22 GMT - status: - code: 200 - message: OK -- request: - body: '{"messages": [{"role": "system", "content": "You are Researcher. You are - a researcher at a leading tech think tank.\nYour personal goal is: Search relevant - data and provide results\nTo give my best complete final answer to the task - respond using 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 complete - as possible, it must be outcome described.\n\nI MUST use these formats, my job - depends on it!"}, {"role": "user", "content": "\nCurrent Task: Perform a search - on specific topics.\n\nThis is the expected criteria for your final answer: - A list of relevant URLs based on the search query.\nyou MUST return the actual - complete content as the final answer, not a summary.\n\n# Useful context: \nExternal - memories:\n\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:"}], "model": - "gpt-4o", "stop": ["\nObservation:"]}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '984' - content-type: - - application/json - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-raw-response: - - 'true' - x-stainless-read-timeout: - - '600.0' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/chat/completions - response: - content: "{\n \"id\": \"chatcmpl-BHcE9342OpU72PR82mknhgcVzhK5H\",\n \"object\": - \"chat.completion\",\n \"created\": 1743538221,\n \"model\": \"gpt-4o-2024-08-06\",\n - \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": - \"assistant\",\n \"content\": \"Thought: I need to gather relevant URLs - based on the search query provided in order to fulfill the task requirements.\\n\\nFinal - Answer: The search query or topics were not specified. Please provide specific - topics or search query to perform a search for relevant URLs.\",\n \"refusal\": - null,\n \"annotations\": []\n },\n \"logprobs\": null,\n \"finish_reason\": - \"stop\"\n }\n ],\n \"usage\": {\n \"prompt_tokens\": 185,\n \"completion_tokens\": - 50,\n \"total_tokens\": 235,\n \"prompt_tokens_details\": {\n \"cached_tokens\": - 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n - \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": - 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": - \"default\",\n \"system_fingerprint\": \"fp_898ac29719\"\n}\n" - headers: - CF-RAY: - - 929ababcdf9c7dfa-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:22 GMT - Server: - - cloudflare - Set-Cookie: - - __cf_bm=26AntG8LjHgDcgN0MYB7TgUTXmoUsQqg8yChWws9CAE-1743538222-1.0.1.1-jo5QRov4A_6L5CaGwhXx2I2aGHzSN6wvrS5Lt2yDpcV5vfTu3FlroYl2d4LBq.ySrtNMDxGQgpsA6fMg0z4iEOXpD5DT7CrJKWRNr4H7Y_k; - path=/; expires=Tue, 01-Apr-25 20:40:22 GMT; domain=.api.openai.com; HttpOnly; - Secure; SameSite=None - - _cfuvid=.HNP7WFC.O40eZMPSJZ4USQu9SYczq5v794aRx34sZg-1743538222787-0.0.1.1-604800000; - path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '860' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - x-ratelimit-limit-requests: - - '50000' - x-ratelimit-limit-tokens: - - '150000000' - x-ratelimit-remaining-requests: - - '49999' - x-ratelimit-remaining-tokens: - - '149999788' - x-ratelimit-reset-requests: - - 1ms - x-ratelimit-reset-tokens: - - 0s - x-request-id: - - req_bf03af6c68765e4393cb60521c5d99ec - http_version: HTTP/1.1 - status_code: 200 -- request: - body: '{"input": ["Thought: I need to gather relevant URLs based on the search - query provided in order to fulfill the task requirements. Final Answer: The - search query or topics were not specified. Please provide specific topics or - search query to perform a search for relevant URLs."], "model": "text-embedding-3-small", - "encoding_format": "base64"}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '344' - content-type: - - application/json - cookie: - - __cf_bm=wQNqc3BNcaCzhFR4owoCJRMIvs7PWqvy7xmWaIr4k.A-1743538220-1.0.1.1-AIxSGyU_kRiSsc4DYqsunqMwAlAn0fhT.P.7_bBBWTyHeVrexxOSRpm5yj6QmiIVcYwEgdJqk9EsHBy9LfadhgMJ5w8LIrHF_sxBFAXOOxc; - _cfuvid=g5w7.LJsKZSYhPzW6M1n.OyrMWQSUF5zX.cFK1vZrQI-1743538220809-0.0.1.1-604800000 - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-read-timeout: - - '600' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/embeddings - response: - content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": - \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n - \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": - 50,\n \"total_tokens\": 50\n }\n}\n" - headers: - CF-RAY: - - 929abac4a8fc7e07-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:24 GMT - Server: - - cloudflare - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-allow-origin: - - '*' - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-model: - - text-embedding-3-small - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '1403' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - via: - - envoy-router-69ff67f767-88tkx - x-envoy-upstream-service-time: - - '1369' - x-ratelimit-limit-requests: - - '10000' - x-ratelimit-limit-tokens: - - '10000000' - x-ratelimit-remaining-requests: - - '9999' - x-ratelimit-remaining-tokens: - - '9999934' - x-ratelimit-reset-requests: - - 6ms - x-ratelimit-reset-tokens: - - 0s - x-request-id: - - req_5a1b9f49c2d200641e58e8cd95ef063a - http_version: HTTP/1.1 - status_code: 200 -- request: - body: '{"messages": [{"role": "user", "content": "Assess the quality of the task - completed based on the description, expected output, and actual results.\n\nTask - Description:\nPerform a search on specific topics.\n\nExpected Output:\nA list - of relevant URLs based on the search query.\n\nActual Output:\nThought: I need - to gather relevant URLs based on the search query provided in order to fulfill - the task requirements.\n\nFinal Answer: The search query or topics were not - specified. Please provide specific topics or search query to perform a search - for relevant URLs.\n\nPlease provide:\n- Bullet points suggestions to improve - future similar tasks\n- A score from 0 to 10 evaluating on completion, quality, - and overall performance- Entities extracted from the task output, if any, their - type, description, and relationships"}], "model": "gpt-4o", "tool_choice": {"type": - "function", "function": {"name": "TaskEvaluation"}}, "tools": [{"type": "function", - "function": {"name": "TaskEvaluation", "description": "Correctly extracted `TaskEvaluation` - with all the required parameters with correct types", "parameters": {"$defs": - {"Entity": {"properties": {"name": {"description": "The name of the entity.", - "title": "Name", "type": "string"}, "type": {"description": "The type of the - entity.", "title": "Type", "type": "string"}, "description": {"description": - "Description of the entity.", "title": "Description", "type": "string"}, "relationships": - {"description": "Relationships of the entity.", "items": {"type": "string"}, - "title": "Relationships", "type": "array"}}, "required": ["name", "type", "description", - "relationships"], "title": "Entity", "type": "object"}}, "properties": {"suggestions": - {"description": "Suggestions to improve future similar tasks.", "items": {"type": - "string"}, "title": "Suggestions", "type": "array"}, "quality": {"description": - "A score from 0 to 10 evaluating on completion, quality, and overall performance, - all taking into account the task description, expected output, and the result - of the task.", "title": "Quality", "type": "number"}, "entities": {"description": - "Entities extracted from the task output.", "items": {"$ref": "#/$defs/Entity"}, - "title": "Entities", "type": "array"}}, "required": ["entities", "quality", - "suggestions"], "type": "object"}}}]}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '2295' - content-type: - - application/json - cookie: - - __cf_bm=26AntG8LjHgDcgN0MYB7TgUTXmoUsQqg8yChWws9CAE-1743538222-1.0.1.1-jo5QRov4A_6L5CaGwhXx2I2aGHzSN6wvrS5Lt2yDpcV5vfTu3FlroYl2d4LBq.ySrtNMDxGQgpsA6fMg0z4iEOXpD5DT7CrJKWRNr4H7Y_k; - _cfuvid=.HNP7WFC.O40eZMPSJZ4USQu9SYczq5v794aRx34sZg-1743538222787-0.0.1.1-604800000 - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-raw-response: - - 'true' - x-stainless-read-timeout: - - '600.0' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/chat/completions - response: - content: "{\n \"id\": \"chatcmpl-BHcEDk89V0nWfSxs0BaUsqqVYrVxj\",\n \"object\": - \"chat.completion\",\n \"created\": 1743538225,\n \"model\": \"gpt-4o-2024-08-06\",\n - \ \"choices\": [\n {\n \"index\": 0,\n \"message\": {\n \"role\": - \"assistant\",\n \"content\": null,\n \"tool_calls\": [\n {\n - \ \"id\": \"call_39zVeoea7WZ0hceVZTcAut7Z\",\n \"type\": - \"function\",\n \"function\": {\n \"name\": \"TaskEvaluation\",\n - \ \"arguments\": \"{\\\"suggestions\\\":[\\\"Ensure that the search - query or specific topics are provided before starting the task.\\\",\\\"Implement - error handling to provide more useful output or alternatives when input is insufficient.\\\",\\\"Provide - a fallback or a default set of topics in case none are provided.\\\",\\\"Clarify - task requirements with stakeholders if the input parameters are unclear.\\\"],\\\"quality\\\":2,\\\"entities\\\":[{\\\"name\\\":\\\"search - query\\\",\\\"type\\\":\\\"Requirement\\\",\\\"description\\\":\\\"A parameter - needed to perform the search operation.\\\",\\\"relationships\\\":[\\\"Without - this entity, the task cannot be completed.\\\"]},{\\\"name\\\":\\\"URLs\\\",\\\"type\\\":\\\"Output\\\",\\\"description\\\":\\\"The - expected result from executing the search.\\\",\\\"relationships\\\":[\\\"Expected - output when the search query is provided.\\\"]}]}\"\n }\n }\n - \ ],\n \"refusal\": null,\n \"annotations\": []\n },\n - \ \"logprobs\": null,\n \"finish_reason\": \"stop\"\n }\n ],\n - \ \"usage\": {\n \"prompt_tokens\": 332,\n \"completion_tokens\": 137,\n - \ \"total_tokens\": 469,\n \"prompt_tokens_details\": {\n \"cached_tokens\": - 0,\n \"audio_tokens\": 0\n },\n \"completion_tokens_details\": {\n - \ \"reasoning_tokens\": 0,\n \"audio_tokens\": 0,\n \"accepted_prediction_tokens\": - 0,\n \"rejected_prediction_tokens\": 0\n }\n },\n \"service_tier\": - \"default\",\n \"system_fingerprint\": \"fp_898ac29719\"\n}\n" - headers: - CF-RAY: - - 929abad21a6b7dfa-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:27 GMT - Server: - - cloudflare - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '2597' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - x-ratelimit-limit-requests: - - '50000' - x-ratelimit-limit-tokens: - - '150000000' - x-ratelimit-remaining-requests: - - '49999' - x-ratelimit-remaining-tokens: - - '149999807' - x-ratelimit-reset-requests: - - 1ms - x-ratelimit-reset-tokens: - - 0s - x-request-id: - - req_a5c36be883759cbc3fec575604f8746e - http_version: HTTP/1.1 - status_code: 200 -- request: - body: '{"input": ["search query(Requirement): A parameter needed to perform the - search operation."], "model": "text-embedding-3-small", "encoding_format": "base64"}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '157' - content-type: - - application/json - cookie: - - __cf_bm=MCDkRAmvHC26iz7BEoKzXwq4j5v_FEX5IQepnW5ARp4-1743538221-1.0.1.1-GXJkwk8HCFy9W0tA9R.s3NWzCNJ7wCiaUFu4YCbra4nQNVJa_mN3jdnmfREeET4QfWbYGCQXuM5GHffwtQZ_W1EV3mUC4JFa3w5CCDqO41Y; - _cfuvid=mRF3.ZghYObsvTKqmSfcqSbJFV0SBPVk2Psc.9DVGlE-1743538221434-0.0.1.1-604800000 - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-read-timeout: - - '600' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/embeddings - response: - content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": - \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n - \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": - 14,\n \"total_tokens\": 14\n }\n}\n" - headers: - CF-RAY: - - 929abae38c117df4-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:28 GMT - Server: - - cloudflare - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-allow-origin: - - '*' - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-model: - - text-embedding-3-small - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '557' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - via: - - envoy-router-d44cf9799-vc45q - x-envoy-upstream-service-time: - - '531' - x-ratelimit-limit-requests: - - '10000' - x-ratelimit-limit-tokens: - - '10000000' - x-ratelimit-remaining-requests: - - '9999' - x-ratelimit-remaining-tokens: - - '9999980' - x-ratelimit-reset-requests: - - 6ms - x-ratelimit-reset-tokens: - - 0s - x-request-id: - - req_91c495419e7c55b5f7396854da1588bc - http_version: HTTP/1.1 - status_code: 200 -- request: - body: '{"input": ["URLs(Output): The expected result from executing the search."], - "model": "text-embedding-3-small", "encoding_format": "base64"}' - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate - connection: - - keep-alive - content-length: - - '139' - content-type: - - application/json - cookie: - - __cf_bm=MCDkRAmvHC26iz7BEoKzXwq4j5v_FEX5IQepnW5ARp4-1743538221-1.0.1.1-GXJkwk8HCFy9W0tA9R.s3NWzCNJ7wCiaUFu4YCbra4nQNVJa_mN3jdnmfREeET4QfWbYGCQXuM5GHffwtQZ_W1EV3mUC4JFa3w5CCDqO41Y; - _cfuvid=mRF3.ZghYObsvTKqmSfcqSbJFV0SBPVk2Psc.9DVGlE-1743538221434-0.0.1.1-604800000 - host: - - api.openai.com - user-agent: - - OpenAI/Python 1.68.2 - x-stainless-arch: - - x64 - x-stainless-async: - - 'false' - x-stainless-lang: - - python - x-stainless-os: - - MacOS - x-stainless-package-version: - - 1.68.2 - x-stainless-read-timeout: - - '600' - x-stainless-retry-count: - - '0' - x-stainless-runtime: - - CPython - x-stainless-runtime-version: - - 3.12.9 - method: POST - uri: https://api.openai.com/v1/embeddings - response: - content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": - \"embedding\",\n \"index\": 0,\n \"embedding\": \"2QN0vI7WDz3L6UY839UQvKWP9zu7wwG7rW2svLu0lzxkK7o8rU/YPJZ4HDz49Iy8cVejvL/2M701F664S/G7PKXaCTy+zMc7c1TRPMm/Wj3zeZo9u5bDvYCejryUbAQ8QyJxvD7ykLy1HiM70WHnPOP5WD0kmj66c4GPvFKEXr39YJU6HgH4vCowMzyYkMw8PNeOPBwWhjygXxc9oU1bPI/E0zzJ7Bi7kNBrPFKEXryXooi8SeWjPIciR7y/50m9HxBiPSE3/Lz1kco8QSXDvNKpJ7y/BR4936jSOyn33Dsb7Jk7JrJuvPfZijyOmme8/STtu0vi0bxdmBc9nRqpu1f/UDyGJRm8MxqAvQK+szxDbQM9d7RBvBM7ozvMIh08gI+kPHn5L7wvq6U8AbKbvPSjhj2y6B49vxSIuwUSjL06dEw9vwUePZZayLytQG6920jiPICPJDz+ioG9sMGEvNXulbwb+4O8gsUovSbfLDwbzkU9+Kn6POPqbjxUrso8TjPYvLvDgTu/BR66fSxiPXNUUT34qXq9lF0aPSJwUr0PrvQ62RJeOuMXrbu7tBe9eO2XvMREaL3jCEO9tOL6u4LFKL23J2k9G+yZPfA0rDyoASS9RGqxvFgsDz2ti4A80FVPvURM3bzr1428z2eLO+dZSbxiEwo90WHnPE9vAL2VS9474eEovRAFnz0ugTk9jayjva6IrryBmzy9I52QPHn5r7xnYb689Gfeu0i7Nz1VyUw7uoqrvEjZi7y4YD89p8V7vUjKITyAgDq97g2SOwXlzTwukKO82mmIu5Z4HLw+tmi91cFXPWQ6JDwc2l286rwLPOILlbtIuze9rXwWvMSAkDzRnQ+899kKPbqZlTwcFgY6Vdg2vFGWGrs+tmg6ne1qvSE3fDw6dMy8xX2+vER5mzyp/lE8dbeTvcJKDLyhiQO9u8OBPKFcRbzaaQg9iWoHPdGdDz3i7cA7WUeRu8V9Pjyd/NS7F4ypvKs0Vjz1voi8VNuIO0egtTyha688xDV+PJvG0DtBFlm9WiZrPEevH70OwLC851nJPHnbWz1DbQM8yMKsPDYF8jyLVfk8lngcvR8Q4jw+tmi8NfnZu9f3WzkTHc+7uX6TPJaHhjwhRuY8cUg5O66mAr0XX2u8x5hAvS6QIz0b7Bk9GZXvvKr7fzwGLY47vN6DPBIvizxDbYO7BzmmPVt9FT2TFVq8m+QkvUsPELzqraE865tlPH1oirtkDWa9daipuxd9v7vCO6I6pdqJPPWRSrtAKBW90Y4lva2LAL3aLWC8sb6yu2MQOD3og7W6AJeZuvWgtLv58To8aXluPAYAULvDONA8aG3WPJ8XV72c/ya87g2SvHjA2b1QbK48WRpTu3Rgab3Qc6O8vszHPAcqPDx5FwQ8z2eLvTMLFjyXdUq6hunwujuA5LsS5Pi8SNmLvLYquzz1vog96Fb3u1X2ir1I2Qu9B0iQPBrggTvjNQG87cL/uWdSVL0o3Nq8jbuNvOhlYTy7lsM8LpCjuzPtwTnZIUi7mtiMPGdDaruLVXk8gtQSvSno8jt8IMq7kwZwvdTEqT1ShF49uFHVu+Ygcz3bOfg8jppnPe3C/zwApoM9oWuvPOZrBTuYvQo7iB91PCpOh7ufNas82zn4u7HchjxiBCA9/BhVvKoKarx56sU8fnSivf9a8TwLe0I8zCIdOigYA70b+4O7nSkTuwCmAz1kDWY8qzTWO6xSKjvs8g+9fVmgvBQa/byWeBy8dbeTPIdAG73DRzq7rpeYvIcxMb0TO6O8NlAEvfe7tjyy94g868ijPFfh/LxOQkK9r3ZyPJz/przkI8U7gJ6OPKF6mbyE75Q8M+3BPD7jJj2vhVw8SNkLPEsPkDxHrx89kP2pPP9acbvHmMC7Ds+avLzAL72zA6E83m98vGzrmrwBwQW9mIFiPPniUL1qxIA7RGqxvIqFCT2hiQM9KfdcPO8ZKjztwn8739UQvTUIxDwjjia84guVu/rffrzwJUK76JKfu+Hwkj3MMQe8Kk6HvDhotL0Nw4K9jawjPK+ymjvxMdo7HTGIPNbNbzx8LzS9bM3GvGdS1LvHthQ8MdURvS11oTwS5Pg80HOjPU4z2DxFZ987/ooBvRZiPbwpMwW9DIdavQk21LpzciU6WRpTumuj2rmKSeG85j7HPGQrurxt2d68UXhGu8RxpjwvqyW6C4qsPItkY7wJNlQ9n0SVPHxNiDwZlW887OMlvILFqDw+tmi9dGDpPOvII71PbwA9UnV0PW/0YLxDMVs8wkqMvagQDr0KQmw85lybOqxhFDyTFdq8iB/1vMn7grztwn88TkLCPLP0tryQ0Gs9HTGIvNt1oDti9bW8gJ6OvTMLFr3bV8y8eO2XvBdf6zzI4AC9ScfPvKWeYb3kFFu9mcmiPFTbiDx+g4y79HbIPBnCrTpRadw7VvO4OsI7ojyLVfk8khgsvFCKArw3XBw9xIAQPCE3fDv0owa9SeUjPFBsrry8scU8wzjQPBi2lTyWWsi4u7SXvLl+Ez0l05S8zOZ0vajjT70THU+9sugeO62LAL0O3gQ8REzduwx4cLw1NQI+bOuaPJ8mwbxL8Ts8v+fJuwyWxDuQ0Gu8UE5aO7HchryOuDu94/lYPI7WD7xJx886vJNxPHkImryOi/27pL8HvXEbe7wm0MI8DbSYPdppiLzwQ5Y8ApF1vIOz7Dy/BZ48eMBZOqkcJj3zW0a5R5HLvK+jsLoXfT88jot9vYuCNz2KZzW8InBSO1Suyjtr0Ji7BeXNvLLKSr33u7a8k0IYO/w2qbzZTga90WHnvPAlQr2BuZC8Bg86Pds5+Dyti4C8OGg0PKs0VjyfRJW76Fb3PHNjO7yhepm8ime1PAUSDD22SA+9KjCzvPe7NjtU2wi9PrZoPcjgADyDs+w8JLgSvPobpzxjELi8Yy6MuxICzTtRlhq8qig+PMjRljzaLeC8k0IYvdXuFT3ryCM8qONPvAYPujxEiAU8llrIuSWmVjzoVve5qhnUOzc+SLvCSoy8egXIvOzyD739QkG8RHmbPdtXzDuyu+C8VuROvX1ZoDrAAsy8hhYvPYlbHTtkHNA58FKAO/1glTwHSBC9fjh6vOLtQD10nJG8dH69u/j0DDxIyiE9FCnnu4TvFD2tXkK8KAmZu3wR4LxRaVw9wBG2vGY3Ujz1gmC8bxI1O/OIBL04SmA9egXIPCxLtbyTQhg8sa9IvAXW47u6e8E7dJyRuyXTFLx+ZTg8mJ82vb8UCL1diS09UXjGPDPe17w3awa8uX4TPOILlbu2Krs6A7thuwK+sztCNC098EMWvRQ40TwxqNM8RVj1vF+wxzupHCY82mkIPMRTUj2koTM921dMvQ7eBL1nf5I8roguvLP0trwXfb+85k2xO+ZrBbpNJ0A8F1/rPOY+x7z9JO28jov9O4YlGTx0jae7XaeBuyFzJLvUxCk7iljLO+Ygczy4UVW8a8GuPD8Nk7s3a4a8u7SXO46pUb2IH3W8LFqfvMeJ1rtbX0E8evZdvRLz4ryNu40865vlPKXLnzzOSTc7yd0uPO7+p73zPXI8iT3JPM1MCb1CNC09wCAgvGHaszxCUoE7LoG5u+QjRTxr0Bi7UnV0u5i9Cr3FfT68hiWZPB8utjwKQuw78V4YO0wqkjv3yiA9RZSdO2vBLrzh8JK8lTz0vJ3tajy8wK+8TTaqvF7CA71AKBU8ODv2uxAUibvryKM7OFlKPc4cebz6DD28GIlXvItzzbqUP8a8VvM4PDZBGrvrjPu7oWsvPGd/Er1xZo28Zka8vApRVj0+tug7+NY4OxrgAbz9JG28V+F8O966jjz49Ay9FGUPvXA8obu5fpO8X5JzvM46zbx1mb+8EPY0Oo6aZz3wQxa8QlKBvAB5xbm/FIg8gW5+PEMi8byKdp88i1V5PEjZCzrjCEM8ZCu6u05CQrzW3Nm5kyREvGvfArwUGv08y+lGPApRVr1ZGtM6c1RRvICAOjzs4yW866pPvORBGT1Hkcu8YuZLPQYtjrx0UX87a98CPQLcB7vJ+wI9XqSvvAyWRDx5zPE8GInXOuPqbjsrHve7Pw2TO2ITCj2vdvI7pZ7hvA2lrrylnmG7O7yMO9Fw0bkthAs7AZRHOzGZ6blqpqw87/tVPNBzI7sKYEC8tydpvIuRobwUR7u8XsKDvGz6BDxL4tE7KiFJvQ2lLjw/DZO8t0W9PBeMKb0o68Q8nybBPNTTE7xX/9C9rUBuufnxOrrf1ZC8CkLsu6s0Vry/FAg95DKvPJRdmrsrHvc7yMKsPJiB4jtzY7s7FGUPvNk/nLouY+W88V4YPab1C7ytQG64qzRWveh0S7yGNAM7k1GCPJU8dLyd/NQ6T2AWuzLwk7zOHPk8kzOuPPWRSr3qvIu8Bi2OPOeGB7yvspo8aG1WvBv7A73eq6S7DsAwvPoMvTq/yXU7kP2pPNgVsLwqEl88MLqPOZZ4nLzLFoW8Dt4EvK5q2jvxXpg8oXoZPJU89Dnft7y8SNkLPILFKDzzW8a8DcOCPICAujxJ9I28gaomu6gBJL1OUay8Z3AoOllHETxkOiS94guVPLZID70fTIq8bNwwPAYtjjsHDOg74gsVvHoFyDxIneM8fVkgPVomaz2uecS8R6A1vMM40Lvgw9S8TCqSuolbHT1kK7q8KRUxvRaAET2Jagc7uX6TvDU1gjtX8OY7PrZovALNHb2YkEw9vtsxvWqIWDuS+lc8untBvWqXwjo7gGQ8t2MRvV16Qz0rLeG8XpVFPeubZT2bqHw89HZIvV/Om7ybxtA89HbIPIbpcDwhN/w7GcKtPNF/u7zr1408k1GCOphyeDz63/479qzMPAp+lDzf1RC8RXZJui5jZbv8Nqm8arUWPUjKoTzSi9M8Mbc9vfBSAD0sSzU7vLFFvZzhUrzMIh08Vbriu35HZDykksm8/oqBvEevn7xesxm9VMwePYPRwDz9JO278AduPXn5LzzoVvc7CVSoOxLkeDyTMy68dGDpPJi9Cr2Ang48dGBpvEjZi7xiEwo9u6WtOwpC7Dq1AM+7HQRKvHkXBLw6g7a8rFKqu846TTwKQuw8REzdvEDsbD2d7Wo84+puuwcMaD1Go4e7WiZrvCpOBzx1ilU8s/Q2PS6Qo7sCoF89CWOSPP5OWTyid0c9+hunvN+3vDzWzW87gbmQO7UtDT0hZDq8A7thO/jWuLzaPEo8MxqAPMDz4Tso3No7/1pxu01FFDxrskS5iknhPDp0TDyLgjc8u8MBPNgzBL1DInE8zhz5PIlMs7wP6hy9P/6oO6xSqjwXm5M7BgDQvPkPjzxh6Z27cEuLPJiQTL0BwYU8KRUxuxD2tDvJsHC84yaXuzuA5LuO1o88wkoMvOzUu7yYgWK95EEZvTqSoDzDOFA6+MfOPDGK/7yd7Wq86FZ3PEnHTzu/yXW8bfcyPJzh0rxDTy+8Bg+6OoKnVLwQ9rQ8UHuYvD2nfrzmXJs7XobbOz62aDzBHc68JtBCPfi4ZLwLiiw93rqOPL8FHj0XX2u8t1QnOSsedzyP8RE7rYuAPPru6DtofEA8WibruwXW47o7cfo7pby1PD2nfjtNRZQ8Ky1hO8z13jtoiyo82zl4PUajBzy83gM8zUwJPOvIIzysQ0A8tR4jPQcqPLyUP8a8ZA3mPE0nwDxMGyi7EiChPLulLT3MBMk8c2M7veiDNbvX99u7RGoxvIgfdT1esxk8HgH4vJDfVT2sUio9gYzSPKkrkDw3Psi84+puvJvVurmTUYK7TUUUvVYCozzmawU8ne1qu2dhvrsmsu47MxoAvGl57jtIneO5HOnHOyse97wF1mO8RqMHPTMLFrzqnre7Sw+QvH1KtrsUZY+6yfuCPGQ6JLwUGv27JdMUPSOdkLsYp6s8wBG2PErEfbxU24i8EhG3u8I7Ij1SwIa8gtSSvAXHeTyP0728pvWLvE5Cwrxk/ns7oG4BvLTx5Dxbbis8TAw+Oz/+KL1AGSs9LpCjOeZNMTvzPfI7F5uTvLuH2TrWCRg9bPoEvaOVm7wUGv28XZiXvFkpPTtdp4E80IKNvF16Q7zLB5s8UE7aOqkrED3AETY9HMtzvK6mgj3Si1M6LmNlu846TTwJYxK9FFalvPFeGLzfqNK8zARJvBd9P7rgtGq8thtRvP9acTz1oLS85lwbPSFV0DxFlJ28yb9aPXRR/7uxoN47w0e6vLK7YDxIrM07Z1LUPIUKFzyxoN47m/MOvOZrhTyFGQE7oF8XPZhy+DtkKzo3v9jfvPW+iDwz/Ku8DaUuvAB5xTxZGtM8OYYIve/71byhiQM99YJgvOYg8zwfH8w7qvt/u1X2ijzrm2U8a8EuvAPZtbzME7O8D650u8RiPDzUtb+6wALMuo7Wj7zALwq9i2TjuqXLn7ypDbw884gEvL7qm7w1Jhg8qgpqO6JZc7wqPx097eDTvKF6GbzFjKg8v+fJvKWty7zbhAq8AtwHvIku37zDR7q8m6j8PJrYjDrqvAs9TUWUupL617ugUC28LGmJuy6BuTuG6XC8oF8XvMREaDxUzJ48aXnuunNUUTz9YBW9uoqrPGvBrrtdpwG9JdMUPaW8NT2nxXu8HAccOkSIhbxwLbe8nA6RPMH/+TxL8bs74u1AO6gQjrzL+DA9gW5+PHr2XTyzEgu9Byo8vYdPBTz2rMw7nP8mPIKn1DxCUoE8LlR7vItkY7wOwDC820hivEnWuTnM5nQ8stm0vG4GnbxVuuI7StPnvOLeVrs9p/67mJ+2PEiOeTvA82G6aIuqO4yOTzxV56C6z2cLvQp+FDwy8JO7Ysj3PDGo0zsF1mO6MwuWvKXaCbpI2Yu8EvPiPN2fDDwUZQ+9AYVdPCkkmzwzGoA6pY/3PIuCNzwxtz27A9m1vNotYLt8Ava7mK6gPL693TxiyPc8pJJJPc4c+boAiC87sxKLO1W6YryKZ7U8tR4jvJDQ6zzefmY82QP0O12YF73jFy28Hz2gO5MzrrxK0+c55i/dvGl5bjuJagc7eczxPOL8Kr208WS8JsFYvKFcRTsKfhQ7P/6oPO3Cf7yTUQK9IWS6vPN5GjzIs0K8KPouPNXfKzpL4lG8xZsSvDUXrjuksB28dGBpvTqSIDtZOCe9HxDiO3jerTxX4fy8qNRlulgdpbwvqyU7oEHDPL7Mx7sjnZA83n5mvGvQGDytQG68AIivvGy+3Dw7rSK8kP0pPYtVeTzYJBo9qRwmvDqhCj31rx67hfusPPkPj7zHiVa81MQpPPwY1TyzA6E70qmnvB3137xNCew7i4K3upvGUDoNtBg8l4S0vH1ZILzRjqU8KRWxPCOdEDyJPUm8DbSYu/WC4DxncKg8KPouu233Mrx8LzQ8DcOCPNTTkzvWze+81hiCu1gdJT0H/X28G/sDveqPzTy6iqs8tQ85vYCPJDxV9oo8Pw0TvEJSgTxkK7q8kNDrO7vDgbzvKJS7p8X7vOhWd7yXhLS8+OWiu1BOWrsTHc+6wBG2u1tuKz2NrKM8JabWPCJwUjwa4IG8CVQoPRvdLzulyx+8u4dZupeTnjyfJkE8gqdUvY/xkTxX4Xy8VuROPM46TbzHiVa8i3NNvGl5bjzXBsa7dZm/PMsWBb0rHne8AJeZPNYJGLuBqiY8xDX+uyXTlDzzTFy9sugevMd67LsSICG8xFNSO9FhZzwqToe8rXyWvHjtF71xZg28HMvzPKb1C7ts6xq71s3vu8ik2Ly/2F+6qgpqPGht1rts+oS7CUW+vDZQhDyLkSG7vN6Duougi7tqpqw8dGDpPAHBBb1i9TU8XaeBvP1glbsC3Ie83qskPCjrxDx1qKm66q0hOyR86jxPbwA883mavNtmNrxIyiE9mK6guwGyGz03TbI8Yx+iuoLFKDyUXRo7rqaCPCbB2DszGoC7hulwu9kwMrwkuBI9x5hAvERqsbsGD7o8SJ3jO1GWmry8zxm7kP0pPZeTHjw7gOS7QlKBvCoS3zoOzxo9C4qsPC+rpbwAiC88N02yPAdIEL11qKk8FVNTO84rYzzftzw8JHzqPFBsLjy+6hu95BTbu09vADsE9wm8F19rPcwxB7v32Yo7g9FAPCbuFjw7cfq6cUg5vF6G2zs6gza91uvDPCE3/LyLoIs8SsR9vLPlTLt1qCk8X92FvJROsDx3tMG8\"\n - \ }\n ],\n \"model\": \"text-embedding-3-small\",\n \"usage\": {\n \"prompt_tokens\": - 12,\n \"total_tokens\": 12\n }\n}\n" - headers: - CF-RAY: - - 929abae938887df4-GRU - Connection: - - keep-alive - Content-Encoding: - - gzip - Content-Type: - - application/json - Date: - - Tue, 01 Apr 2025 20:10:29 GMT - Server: - - cloudflare - Transfer-Encoding: - - chunked - X-Content-Type-Options: - - nosniff - access-control-allow-origin: - - '*' - access-control-expose-headers: - - X-Request-ID - alt-svc: - - h3=":443"; ma=86400 - cf-cache-status: - - DYNAMIC - openai-model: - - text-embedding-3-small - openai-organization: - - crewai-iuxna1 - openai-processing-ms: - - '199' - openai-version: - - '2020-10-01' - strict-transport-security: - - max-age=31536000; includeSubDomains; preload - via: - - envoy-router-f47df6cdf-hhnd7 - x-envoy-upstream-service-time: - - '105' - x-ratelimit-limit-requests: - - '10000' - x-ratelimit-limit-tokens: - - '10000000' - x-ratelimit-remaining-requests: - - '9999' - x-ratelimit-remaining-tokens: - - '9999984' - x-ratelimit-reset-requests: - - 6ms - x-ratelimit-reset-tokens: - - 0s - x-request-id: - - req_cfdd836532f45e9c2f03d332153438f6 - http_version: HTTP/1.1 - status_code: 200 -version: 1 diff --git a/tests/memory/external/external_memory_test.py b/tests/memory/external_memory_test.py similarity index 81% rename from tests/memory/external/external_memory_test.py rename to tests/memory/external_memory_test.py index 8cbc34ef9..eae69a5af 100644 --- a/tests/memory/external/external_memory_test.py +++ b/tests/memory/external_memory_test.py @@ -61,6 +61,35 @@ def crew_with_external_memory(external_memory_with_mocked_config, patch_configur return crew +@pytest.fixture +def crew_with_external_memory_without_memory_flag( + external_memory_with_mocked_config, patch_configure_mem0 +): + agent = Agent( + role="Researcher", + goal="Search relevant data and provide results", + backstory="You are a researcher at a leading tech think tank.", + tools=[], + verbose=True, + ) + + task = Task( + description="Perform a search on specific topics.", + expected_output="A list of relevant URLs based on the search query.", + agent=agent, + ) + + crew = Crew( + agents=[agent], + tasks=[task], + verbose=True, + process=Process.sequential, + external_memory=external_memory_with_mocked_config, + ) + + return crew + + def test_external_memory_initialization(external_memory_with_mocked_config): assert external_memory_with_mocked_config is not None assert isinstance(external_memory_with_mocked_config, ExternalMemory) @@ -137,7 +166,9 @@ def test_crew_external_memory_reset(mem_type, crew_with_external_memory): @pytest.mark.parametrize("mem_method", ["search", "save"]) @pytest.mark.vcr(filter_headers=["authorization"]) -def test_crew_external_memory_save(mem_method, crew_with_external_memory): +def test_crew_external_memory_save_with_memory_flag( + mem_method, crew_with_external_memory +): with patch( f"crewai.memory.external.external_memory.ExternalMemory.{mem_method}" ) as mock_method: @@ -145,6 +176,18 @@ def test_crew_external_memory_save(mem_method, crew_with_external_memory): assert mock_method.call_count > 0 +@pytest.mark.parametrize("mem_method", ["search", "save"]) +@pytest.mark.vcr(filter_headers=["authorization"]) +def test_crew_external_memory_save_using_crew_without_memory_flag( + mem_method, crew_with_external_memory_without_memory_flag +): + with patch( + f"crewai.memory.external.external_memory.ExternalMemory.{mem_method}" + ) as mock_method: + crew_with_external_memory_without_memory_flag.kickoff() + assert mock_method.call_count > 0 + + def test_external_memory_custom_storage(crew_with_external_memory): class CustomStorage(Storage): def __init__(self): diff --git a/tests/project_test.py b/tests/project_test.py index e0813a13f..c07922351 100644 --- a/tests/project_test.py +++ b/tests/project_test.py @@ -1,6 +1,9 @@ +from typing import List + import pytest from crewai.agent import Agent +from crewai.agents.agent_builder.base_agent import BaseAgent from crewai.crew import Crew from crewai.llm import LLM from crewai.project import ( @@ -40,28 +43,32 @@ class InternalCrew: agents_config = "config/agents.yaml" tasks_config = "config/tasks.yaml" + agents: List[BaseAgent] + tasks: List[Task] + @llm def local_llm(self): return LLM( - model='openai/model_name', + model="openai/model_name", api_key="None", - base_url="http://xxx.xxx.xxx.xxx:8000/v1") + base_url="http://xxx.xxx.xxx.xxx:8000/v1", + ) @agent def researcher(self): - return Agent(config=self.agents_config["researcher"]) + return Agent(config=self.agents_config["researcher"]) # type: ignore[index] @agent def reporting_analyst(self): - return Agent(config=self.agents_config["reporting_analyst"]) + return Agent(config=self.agents_config["reporting_analyst"]) # type: ignore[index] @task def research_task(self): - return Task(config=self.tasks_config["research_task"]) + return Task(config=self.tasks_config["research_task"]) # type: ignore[index] @task def reporting_task(self): - return Task(config=self.tasks_config["reporting_task"]) + return Task(config=self.tasks_config["reporting_task"]) # type: ignore[index] @before_kickoff def modify_inputs(self, inputs): @@ -165,24 +172,27 @@ def test_before_kickoff_with_none_input(): def test_multiple_before_after_kickoff(): @CrewBase class MultipleHooksCrew: + agents: List[BaseAgent] + tasks: List[Task] + agents_config = "config/agents.yaml" tasks_config = "config/tasks.yaml" @agent def researcher(self): - return Agent(config=self.agents_config["researcher"]) + return Agent(config=self.agents_config["researcher"]) # type: ignore[index] @agent def reporting_analyst(self): - return Agent(config=self.agents_config["reporting_analyst"]) + return Agent(config=self.agents_config["reporting_analyst"]) # type: ignore[index] @task def research_task(self): - return Task(config=self.tasks_config["research_task"]) + return Task(config=self.tasks_config["research_task"]) # type: ignore[index] @task def reporting_task(self): - return Task(config=self.tasks_config["reporting_task"]) + return Task(config=self.tasks_config["reporting_task"]) # type: ignore[index] @before_kickoff def first_before(self, inputs): diff --git a/tests/storage/test_mem0_storage.py b/tests/storage/test_mem0_storage.py index f9e56739f..f0c62d480 100644 --- a/tests/storage/test_mem0_storage.py +++ b/tests/storage/test_mem0_storage.py @@ -29,7 +29,7 @@ def mem0_storage_with_mocked_config(mock_mem0_memory): """Fixture to create a Mem0Storage instance with mocked dependencies""" # Patch the Memory class to return our mock - with patch("mem0.memory.main.Memory.from_config", return_value=mock_mem0_memory): + with patch("mem0.memory.main.Memory.from_config", return_value=mock_mem0_memory) as mock_from_config: config = { "vector_store": { "provider": "mock_vector_store", @@ -66,13 +66,15 @@ def mem0_storage_with_mocked_config(mock_mem0_memory): ) mem0_storage = Mem0Storage(type="short_term", crew=crew) - return mem0_storage + return mem0_storage, mock_from_config, config def test_mem0_storage_initialization(mem0_storage_with_mocked_config, mock_mem0_memory): """Test that Mem0Storage initializes correctly with the mocked config""" - assert mem0_storage_with_mocked_config.memory_type == "short_term" - assert mem0_storage_with_mocked_config.memory is mock_mem0_memory + mem0_storage, mock_from_config, config = mem0_storage_with_mocked_config + assert mem0_storage.memory_type == "short_term" + assert mem0_storage.memory is mock_mem0_memory + mock_from_config.assert_called_once_with(config) @pytest.fixture diff --git a/tests/task_test.py b/tests/task_test.py index 297ed084f..b09f69646 100644 --- a/tests/task_test.py +++ b/tests/task_test.py @@ -3,6 +3,7 @@ import hashlib import json import os +import time from functools import partial from typing import Tuple, Union from unittest.mock import MagicMock, patch @@ -1368,3 +1369,90 @@ def test_interpolate_valid_types(): assert parsed["optional"] is None assert parsed["nested"]["flag"] is True assert parsed["nested"]["empty"] is None + + +def test_task_with_no_max_execution_time(): + researcher = Agent( + role="Researcher", + goal="Make the best research and analysis on content about AI and AI agents", + backstory="You're an expert researcher, specialized in technology, software engineering, AI and startups. You work as a freelancer and is now working on doing research and analysis for a new customer.", + allow_delegation=False, + max_execution_time=None + ) + + task = Task( + description="Give me a list of 5 interesting ideas to explore for na article, what makes them unique and interesting.", + expected_output="Bullet point list of 5 interesting ideas.", + agent=researcher, + ) + + with patch.object(Agent, "_execute_without_timeout", return_value = "ok") as execute: + result = task.execute_sync(agent=researcher) + assert result.raw == "ok" + execute.assert_called_once() + + +@pytest.mark.vcr(filter_headers=["authorization"]) +def test_task_with_max_execution_time(): + from crewai.tools import tool + """Test that execution raises TimeoutError when max_execution_time is exceeded.""" + + @tool("what amazing tool", result_as_answer=True) + def my_tool() -> str: + "My tool" + time.sleep(1) + return "okay" + + researcher = Agent( + role="Researcher", + goal="Make the best research and analysis on content about AI and AI agents. Use the tool provided to you.", + backstory=( + "You're an expert researcher, specialized in technology, software engineering, AI and startups. " + "You work as a freelancer and are now working on doing research and analysis for a new customer." + ), + allow_delegation=False, + tools=[my_tool], + max_execution_time=4 + ) + + task = Task( + description="Give me a list of 5 interesting ideas to explore for an article, what makes them unique and interesting.", + expected_output="Bullet point list of 5 interesting ideas.", + agent=researcher, + ) + + result = task.execute_sync(agent=researcher) + assert result.raw == "okay" + + +@pytest.mark.vcr(filter_headers=["authorization"]) +def test_task_with_max_execution_time_exceeded(): + from crewai.tools import tool + """Test that execution raises TimeoutError when max_execution_time is exceeded.""" + + @tool("what amazing tool", result_as_answer=True) + def my_tool() -> str: + "My tool" + time.sleep(10) + return "okay" + + researcher = Agent( + role="Researcher", + goal="Make the best research and analysis on content about AI and AI agents. Use the tool provided to you.", + backstory=( + "You're an expert researcher, specialized in technology, software engineering, AI and startups. " + "You work as a freelancer and are now working on doing research and analysis for a new customer." + ), + allow_delegation=False, + tools=[my_tool], + max_execution_time=1 + ) + + task = Task( + description="Give me a list of 5 interesting ideas to explore for an article, what makes them unique and interesting.", + expected_output="Bullet point list of 5 interesting ideas.", + agent=researcher, + ) + + with pytest.raises(TimeoutError): + task.execute_sync(agent=researcher) \ No newline at end of file diff --git a/tests/tools/agent_tools/agent_tools_test.py b/tests/tools/agent_tools/agent_tools_test.py index 9aea7b4bc..6cb5d26e7 100644 --- a/tests/tools/agent_tools/agent_tools_test.py +++ b/tests/tools/agent_tools/agent_tools_test.py @@ -16,6 +16,13 @@ delegate_tool = tools[0] ask_tool = tools[1] +@pytest.fixture(scope="module") +def vcr_config(request) -> dict: + return { + "cassette_library_dir": "tests/tools/agent_tools/cassettes", + } + + @pytest.mark.vcr(filter_headers=["authorization"]) def test_delegate_work(): result = delegate_tool.run( diff --git a/tests/utilities/test_converter.py b/tests/utilities/test_converter.py index 3f4a4d07b..70d1ce718 100644 --- a/tests/utilities/test_converter.py +++ b/tests/utilities/test_converter.py @@ -21,6 +21,13 @@ from crewai.utilities.converter import ( from crewai.utilities.pydantic_schema_parser import PydanticSchemaParser +@pytest.fixture(scope="module") +def vcr_config(request) -> dict: + return { + "cassette_library_dir": "tests/utilities/cassettes", + } + + # Sample Pydantic models for testing class EmailResponse(BaseModel): previous_message_content: str diff --git a/tests/utilities/test_events.py b/tests/utilities/test_events.py index 2a6e6c41c..150a383cb 100644 --- a/tests/utilities/test_events.py +++ b/tests/utilities/test_events.py @@ -50,10 +50,13 @@ from crewai.utilities.events.tool_usage_events import ( ToolUsageErrorEvent, ) -# Skip streaming tests when running in CI/CD environments -skip_streaming_in_ci = pytest.mark.skipif( - os.getenv("CI") is not None, reason="Skipping streaming tests in CI/CD environments" -) + +@pytest.fixture(scope="module") +def vcr_config(request) -> dict: + return { + "cassette_library_dir": "tests/utilities/cassettes", + } + base_agent = Agent( role="base_agent", @@ -625,7 +628,6 @@ def test_llm_emits_call_failed_event(): assert received_events[0].error == error_message -@skip_streaming_in_ci @pytest.mark.vcr(filter_headers=["authorization"]) def test_llm_emits_stream_chunk_events(): """Test that LLM emits stream chunk events when streaming is enabled.""" @@ -650,7 +652,6 @@ def test_llm_emits_stream_chunk_events(): assert "".join(received_chunks) == response -@skip_streaming_in_ci @pytest.mark.vcr(filter_headers=["authorization"]) def test_llm_no_stream_chunks_when_streaming_disabled(): """Test that LLM doesn't emit stream chunk events when streaming is disabled.""" diff --git a/uv.lock b/uv.lock index 21c8445f0..d9c9d5c66 100644 --- a/uv.lock +++ b/uv.lock @@ -1,42 +1,32 @@ version = 1 +revision = 1 requires-python = ">=3.10, <3.13" resolution-markers = [ - "python_full_version < '3.11' and platform_system == 'Darwin' and sys_platform == 'darwin'", - "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform == 'darwin'", - "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_system != 'Darwin' and sys_platform == 'darwin') or (python_full_version < '3.11' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'darwin')", - "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_system == 'Darwin' and sys_platform == 'linux'", - "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform == 'linux'", - "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'linux'", - "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_system == 'Darwin' and sys_platform != 'darwin') or (python_full_version < '3.11' and platform_system == 'Darwin' and sys_platform != 'darwin' and sys_platform != 'linux')", - "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform != 'darwin' and sys_platform != 'linux'", - "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_system != 'Darwin' and sys_platform != 'darwin') or (python_full_version < '3.11' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'darwin' and sys_platform != 'linux')", - "python_full_version == '3.11.*' and platform_system == 'Darwin' and sys_platform == 'darwin'", - "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform == 'darwin'", - "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_system != 'Darwin' and sys_platform == 'darwin') or (python_full_version == '3.11.*' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'darwin')", - "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_system == 'Darwin' and sys_platform == 'linux'", - "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform == 'linux'", - "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'linux'", - "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_system == 'Darwin' and sys_platform != 'darwin') or (python_full_version == '3.11.*' and platform_system == 'Darwin' and sys_platform != 'darwin' and sys_platform != 'linux')", - "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform != 'darwin' and sys_platform != 'linux'", - "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_system != 'Darwin' and sys_platform != 'darwin') or (python_full_version == '3.11.*' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'darwin' and sys_platform != 'linux')", - "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_system == 'Darwin' and sys_platform == 'darwin'", - "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform == 'darwin'", - "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and platform_system != 'Darwin' and sys_platform == 'darwin') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'darwin')", - "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Darwin' and sys_platform == 'linux'", - "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform == 'linux'", - "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'linux'", - "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and platform_system == 'Darwin' and sys_platform != 'darwin') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_system == 'Darwin' and sys_platform != 'darwin' and sys_platform != 'linux')", - "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform != 'darwin' and sys_platform != 'linux'", - "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and platform_system != 'Darwin' and sys_platform != 'darwin') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'darwin' and sys_platform != 'linux')", - "python_full_version >= '3.12.4' and platform_system == 'Darwin' and sys_platform == 'darwin'", - "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform == 'darwin'", - "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_system != 'Darwin' and sys_platform == 'darwin') or (python_full_version >= '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'darwin')", - "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Darwin' and sys_platform == 'linux'", - "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform == 'linux'", - "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'linux'", - "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_system == 'Darwin' and sys_platform != 'darwin') or (python_full_version >= '3.12.4' and platform_system == 'Darwin' and sys_platform != 'darwin' and sys_platform != 'linux')", - "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform != 'darwin' and sys_platform != 'linux'", - "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_system != 'Darwin' and sys_platform != 'darwin') or (python_full_version >= '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'darwin' and sys_platform != 'linux')", + "python_full_version < '3.11' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'", + "python_full_version < '3.11' and platform_python_implementation != 'PyPy' and sys_platform == 'darwin'", + "python_version < '0'", + "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux'", + "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux'", + "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux') or (python_full_version < '3.11' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version < '3.11' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "python_full_version == '3.11.*' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'", + "python_full_version == '3.11.*' and platform_python_implementation != 'PyPy' and sys_platform == 'darwin'", + "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux'", + "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux'", + "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux') or (python_full_version == '3.11.*' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version == '3.11.*' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'", + "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_python_implementation != 'PyPy' and sys_platform == 'darwin'", + "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux'", + "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux'", + "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "python_full_version >= '3.12.4' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'", + "python_full_version >= '3.12.4' and platform_python_implementation != 'PyPy' and sys_platform == 'darwin'", + "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux'", + "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux'", + "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12.4' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12.4' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", ] [[package]] @@ -344,7 +334,7 @@ name = "build" version = "1.2.2.post1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "os_name == 'nt'" }, + { 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 = "importlib-metadata", marker = "python_full_version < '3.10.2'" }, { name = "packaging" }, { name = "pyproject-hooks" }, @@ -579,7 +569,7 @@ name = "click" version = "8.1.8" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "platform_system == 'Windows'" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593 } wheels = [ @@ -703,8 +693,8 @@ dev = [ { name = "pre-commit" }, { name = "pytest" }, { name = "pytest-asyncio" }, + { name = "pytest-recording" }, { name = "pytest-subprocess" }, - { name = "pytest-vcr" }, { name = "python-dotenv" }, { name = "ruff" }, ] @@ -745,6 +735,7 @@ requires-dist = [ { name = "tomli-w", specifier = ">=1.1.0" }, { name = "uv", specifier = ">=0.4.25" }, ] +provides-extras = ["tools", "embeddings", "agentops", "fastembed", "pdfplumber", "pandas", "openpyxl", "mem0", "docling", "aisuite"] [package.metadata.requires-dev] dev = [ @@ -759,8 +750,8 @@ dev = [ { name = "pre-commit", specifier = ">=3.6.0" }, { name = "pytest", specifier = ">=8.0.0" }, { name = "pytest-asyncio", specifier = ">=0.23.7" }, + { name = "pytest-recording", specifier = ">=0.13.2" }, { name = "pytest-subprocess", specifier = ">=1.5.2" }, - { name = "pytest-vcr", specifier = ">=1.0.2" }, { name = "python-dotenv", specifier = ">=1.0.0" }, { name = "ruff", specifier = ">=0.8.2" }, ] @@ -2518,7 +2509,7 @@ version = "1.6.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, - { name = "colorama", marker = "platform_system == 'Windows'" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, { name = "ghp-import" }, { name = "jinja2" }, { name = "markdown" }, @@ -2699,7 +2690,7 @@ version = "2.10.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pygments" }, - { name = "pywin32", marker = "platform_system == 'Windows'" }, + { name = "pywin32", marker = "sys_platform == 'win32'" }, { name = "tqdm" }, ] sdist = { url = "https://files.pythonhosted.org/packages/3a/93/80ac75c20ce54c785648b4ed363c88f148bf22637e10c9863db4fbe73e74/mpire-2.10.2.tar.gz", hash = "sha256:f66a321e93fadff34585a4bfa05e95bd946cf714b442f51c529038eb45773d97", size = 271270 } @@ -2946,7 +2937,7 @@ name = "nvidia-cudnn-cu12" version = "9.1.0.70" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" }, + { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/9f/fd/713452cd72343f682b1c7b9321e23829f00b842ceaedcda96e742ea0b0b3/nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl", hash = "sha256:165764f44ef8c61fcdfdfdbe769d687e06374059fbb388b6c89ecb0e28793a6f", size = 664752741 }, @@ -2973,9 +2964,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 platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" }, - { name = "nvidia-cusparse-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" }, - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" }, + { name = "nvidia-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')" }, ] 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 }, @@ -2986,7 +2977,7 @@ name = "nvidia-cusparse-cu12" version = "12.1.0.106" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/65/5b/cfaeebf25cd9fdec14338ccb16f6b2c4c7fa9163aefcf057d86b9cc248bb/nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl", hash = "sha256:f3b50f42cf363f86ab21f720998517a659a48131e8d538dc02f8768237bd884c", size = 195958278 }, @@ -2997,7 +2988,6 @@ name = "nvidia-nccl-cu12" version = "2.20.5" source = { registry = "https://pypi.org/simple" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c1/bb/d09dda47c881f9ff504afd6f9ca4f502ded6d8fc2f572cacc5e39da91c28/nvidia_nccl_cu12-2.20.5-py3-none-manylinux2014_aarch64.whl", hash = "sha256:1fc150d5c3250b170b29410ba682384b14581db722b2531b0d8d33c595f33d01", size = 176238458 }, { url = "https://files.pythonhosted.org/packages/4b/2a/0a131f572aa09f741c30ccd45a8e56316e8be8dfc7bc19bf0ab7cfef7b19/nvidia_nccl_cu12-2.20.5-py3-none-manylinux2014_x86_64.whl", hash = "sha256:057f6bf9685f75215d0c53bf3ac4a10b3e6578351de307abad9e18a99182af56", size = 176249402 }, ] @@ -3007,7 +2997,6 @@ version = "12.6.85" source = { registry = "https://pypi.org/simple" } wheels = [ { url = "https://files.pythonhosted.org/packages/9d/d7/c5383e47c7e9bf1c99d5bd2a8c935af2b6d705ad831a7ec5c97db4d82f4f/nvidia_nvjitlink_cu12-12.6.85-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:eedc36df9e88b682efe4309aa16b5b4e78c2407eac59e8c10a6a47535164369a", size = 19744971 }, - { url = "https://files.pythonhosted.org/packages/31/db/dc71113d441f208cdfe7ae10d4983884e13f464a6252450693365e166dcf/nvidia_nvjitlink_cu12-12.6.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cf4eaa7d4b6b543ffd69d6abfb11efdeb2db48270d94dfd3a452c24150829e41", size = 19270338 }, ] [[package]] @@ -3525,7 +3514,7 @@ name = "portalocker" version = "2.10.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pywin32", marker = "platform_system == 'Windows'" }, + { name = "pywin32", marker = "sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ed/d3/c6c64067759e87af98cc668c1cc75171347d0f1577fab7ca3749134e3cd4/portalocker-2.10.1.tar.gz", hash = "sha256:ef1bf844e878ab08aee7e40184156e1151f228f103aa5c6bd0724cc330960f8f", size = 40891 } wheels = [ @@ -4075,6 +4064,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/96/31/6607dab48616902f76885dfcf62c08d929796fc3b2d2318faf9fd54dbed9/pytest_asyncio-0.24.0-py3-none-any.whl", hash = "sha256:a811296ed596b69bf0b6f3dc40f83bcaf341b155a269052d82efa2b25ac7037b", size = 18024 }, ] +[[package]] +name = "pytest-recording" +version = "0.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, + { name = "vcrpy", version = "5.1.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" }, + { name = "vcrpy", version = "7.0.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fe/2a/ea6b8036ae01979eae02d8ad5a7da14dec90d9176b613e49fb8d134c78fc/pytest_recording-0.13.2.tar.gz", hash = "sha256:000c3babbb466681457fd65b723427c1779a0c6c17d9e381c3142a701e124877", size = 25270 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/52/8e67a969e9fad3fa5ec4eab9f2a7348ff04692065c7deda21d76e9112703/pytest_recording-0.13.2-py3-none-any.whl", hash = "sha256:3820fe5743d1ac46e807989e11d073cb776a60bdc544cf43ebca454051b22d13", size = 12783 }, +] + [[package]] name = "pytest-subprocess" version = "1.5.2" @@ -4087,19 +4090,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/10/77/a80e8f9126b95ffd5ad4d04bd14005c68dcbf0d88f53b2b14893f6cc7232/pytest_subprocess-1.5.2-py3-none-any.whl", hash = "sha256:23ac7732aa8bd45f1757265b1316eb72a7f55b41fb21e2ca22e149ba3629fa46", size = 20886 }, ] -[[package]] -name = "pytest-vcr" -version = "1.0.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pytest" }, - { name = "vcrpy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/1a/60/104c619483c1a42775d3f8b27293f1ecfc0728014874d065e68cb9702d49/pytest-vcr-1.0.2.tar.gz", hash = "sha256:23ee51b75abbcc43d926272773aae4f39f93aceb75ed56852d0bf618f92e1896", size = 3810 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9d/d3/ff520d11e6ee400602711d1ece8168dcfc5b6d8146fb7db4244a6ad6a9c3/pytest_vcr-1.0.2-py2.py3-none-any.whl", hash = "sha256:2f316e0539399bea0296e8b8401145c62b6f85e9066af7e57b6151481b0d6d9c", size = 4137 }, -] - [[package]] name = "python-bidi" version = "0.6.3" @@ -5032,19 +5022,19 @@ dependencies = [ { name = "fsspec" }, { name = "jinja2" }, { name = "networkx" }, - { 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 = "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 = "sympy" }, - { name = "triton", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, + { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, { name = "typing-extensions" }, ] wheels = [ @@ -5091,7 +5081,7 @@ name = "tqdm" version = "4.66.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "platform_system == 'Windows'" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/58/83/6ba9844a41128c62e810fddddd72473201f3eacde02046066142a2d96cc5/tqdm-4.66.5.tar.gz", hash = "sha256:e1020aef2e5096702d8a025ac7d16b1577279c9d63f8375b63083e9a5f0fcbad", size = 169504 } wheels = [ @@ -5133,7 +5123,7 @@ name = "triton" version = "3.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "filelock", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" }, + { name = "filelock", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/45/27/14cc3101409b9b4b9241d2ba7deaa93535a217a211c86c4cc7151fb12181/triton-3.0.0-1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e1efef76935b2febc365bfadf74bcb65a6f959a9872e5bddf44cc9e0adce1e1a", size = 209376304 }, @@ -5288,16 +5278,59 @@ wheels = [ name = "vcrpy" version = "5.1.0" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'", + "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux'", + "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux') or (python_full_version < '3.11' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "python_full_version == '3.11.*' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'", + "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux'", + "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux') or (python_full_version == '3.11.*' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'", + "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux'", + "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "python_full_version >= '3.12.4' and platform_python_implementation == 'PyPy' and sys_platform == 'darwin'", + "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux'", + "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_python_implementation == 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12.4' and platform_python_implementation == 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", +] dependencies = [ - { name = "pyyaml" }, - { name = "wrapt" }, - { name = "yarl" }, + { name = "pyyaml", marker = "platform_python_implementation == 'PyPy'" }, + { name = "wrapt", marker = "platform_python_implementation == 'PyPy'" }, + { name = "yarl", marker = "platform_python_implementation == 'PyPy'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a5/ea/a166a3cce4ac5958ba9bbd9768acdb1ba38ae17ff7986da09fa5b9dbc633/vcrpy-5.1.0.tar.gz", hash = "sha256:bbf1532f2618a04f11bce2a99af3a9647a32c880957293ff91e0a5f187b6b3d2", size = 84576 } wheels = [ { url = "https://files.pythonhosted.org/packages/2a/5b/3f70bcb279ad30026cc4f1df0a0491a0205a24dddd88301f396c485de9e7/vcrpy-5.1.0-py2.py3-none-any.whl", hash = "sha256:605e7b7a63dcd940db1df3ab2697ca7faf0e835c0852882142bafb19649d599e", size = 41969 }, ] +[[package]] +name = "vcrpy" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_python_implementation != 'PyPy' and sys_platform == 'darwin'", + "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux'", + "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version < '3.11' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "python_full_version == '3.11.*' and platform_python_implementation != 'PyPy' and sys_platform == 'darwin'", + "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux'", + "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version == '3.11.*' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_python_implementation != 'PyPy' and sys_platform == 'darwin'", + "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux'", + "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", + "python_full_version >= '3.12.4' and platform_python_implementation != 'PyPy' and sys_platform == 'darwin'", + "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux'", + "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (python_full_version >= '3.12.4' and platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'linux')", +] +dependencies = [ + { name = "pyyaml", marker = "platform_python_implementation != 'PyPy'" }, + { name = "urllib3", marker = "platform_python_implementation != 'PyPy'" }, + { name = "wrapt", marker = "platform_python_implementation != 'PyPy'" }, + { name = "yarl", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/d3/856e06184d4572aada1dd559ddec3bedc46df1f2edc5ab2c91121a2cccdb/vcrpy-7.0.0.tar.gz", hash = "sha256:176391ad0425edde1680c5b20738ea3dc7fb942520a48d2993448050986b3a50", size = 85502 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/5d/1f15b252890c968d42b348d1e9b0aa12d5bf3e776704178ec37cceccdb63/vcrpy-7.0.0-py2.py3-none-any.whl", hash = "sha256:55791e26c18daa363435054d8b35bd41a4ac441b6676167635d1b37a71dbe124", size = 42321 }, +] + [[package]] name = "virtualenv" version = "20.27.0"