bumping version

conftest.py

@@ -12,7 +12,6 @@ from dotenv import load_dotenv
 import pytest
 from vcr.request import Request  # type: ignore[import-untyped]
 
-
 try:
     import vcr.stubs.httpx_stubs as httpx_stubs  # type: ignore[import-untyped]
 except ModuleNotFoundError:

docs/en/changelog.mdx

@@ -4,88 +4,6 @@ description: "Product updates, improvements, and bug fixes for CrewAI"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="Mar 04, 2026">
-  ## v1.10.1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1)
-
-  ## What's Changed
-
-  ### Features
-  - Upgrade Gemini GenAI
-
-  ### Bug Fixes
-  - Adjust executor listener value to avoid recursion
-  - Group parallel function response parts in a single Content object in Gemini
-  - Surface thought output from thinking models in Gemini
-  - Load MCP and platform tools when agent tools are None
-  - Support Jupyter environments with running event loops in A2A
-  - Use anonymous ID for ephemeral traces
-  - Conditionally pass plus header
-  - Skip signal handler registration in non-main threads for telemetry
-  - Inject tool errors as observations and resolve name collisions
-  - Upgrade pypdf from 4.x to 6.7.4 to resolve Dependabot alerts
-  - Resolve critical and high Dependabot security alerts
-
-  ### Documentation
-  - Sync Composio tool documentation across locales
-
-  ## Contributors
-
-  @giulio-leone, @greysonlalonde, @haxzie, @joaomdmoura, @lorenzejay, @mattatcha, @mplachta, @nicoferdi96
-
-</Update>
-
-<Update label="Feb 27, 2026">
-  ## v1.10.1a1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## What's Changed
-
-  ### Features
-  - Implement asynchronous invocation support in step callback methods
-  - Implement lazy loading for heavy dependencies in Memory module
-
-  ### Documentation
-  - Update changelog and version for v1.10.0
-
-  ### Refactoring
-  - Refactor step callback methods to support asynchronous invocation
-  - Refactor to implement lazy loading for heavy dependencies in Memory module
-
-  ### Bug Fixes
-  - Fix branch for release notes
-
-  ## Contributors
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="Feb 27, 2026">
-  ## v1.10.1a1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## What's Changed
-
-  ### Refactoring
-  - Refactor step callback methods to support asynchronous invocation
-  - Implement lazy loading for heavy dependencies in Memory module
-
-  ### Documentation
-  - Update changelog and version for v1.10.0
-
-  ### Bug Fixes
-  - Make branch for release notes
-
-  ## Contributors
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
 <Update label="Feb 26, 2026">
   ## v1.10.0
 

docs/en/guides/migration/migrating-from-langgraph.mdx

@@ -1,518 +0,0 @@
----
-title: "Moving from LangGraph to CrewAI: A Practical Guide for Engineers"
-description: If you already have built with LangGraph, learn how to quickly port your projects to CrewAI
-icon: switch
-mode: "wide"
----
-
-You've built agents with LangGraph. You've wrestled with `StateGraph`, wired up conditional edges, and debugged state dictionaries at 2 AM. It works — but somewhere along the way, you started wondering if there's a better path to production.
-
-There is. **CrewAI Flows** gives you the same power — event-driven orchestration, conditional routing, shared state — with dramatically less boilerplate and a mental model that maps cleanly to how you actually think about multi-step AI workflows.
-
-This article walks through the core concepts side by side, shows real code comparisons, and demonstrates why CrewAI Flows is the framework you'll want to reach for next.
-
----
-
-## The Mental Model Shift
-
-LangGraph asks you to think in **graphs**: nodes, edges, and state dictionaries. Every workflow is a directed graph where you explicitly wire transitions between computation steps. It's powerful, but the abstraction carries overhead — especially when your workflow is fundamentally sequential with a few decision points.
-
-CrewAI Flows asks you to think in **events**: methods that start things, methods that listen for results, and methods that route execution. The topology of your workflow emerges from decorator annotations rather than explicit graph construction. This isn't just syntactic sugar — it changes how you design, read, and maintain your pipelines.
-
-Here's the core mapping:
-
-| LangGraph Concept | CrewAI Flows Equivalent |
-| --- | --- |
-| `StateGraph` class | `Flow` class |
-| `add_node()` | Methods decorated with `@start`, `@listen` |
-| `add_edge()` / `add_conditional_edges()` | `@listen()` / `@router()` decorators |
-| `TypedDict` state | Pydantic `BaseModel` state |
-| `START` / `END` constants | `@start()` decorator / natural method return |
-| `graph.compile()` | `flow.kickoff()` |
-| Checkpointer / persistence | Built-in memory (LanceDB-backed) |
-
-Let's see what this looks like in practice.
-
----
-
-## Demo 1: A Simple Sequential Pipeline
-
-Imagine you're building a pipeline that takes a topic, researches it, writes a summary, and formats the output. Here's how each framework handles it.
-
-### LangGraph Approach
-
-```python
-from typing import TypedDict
-from langgraph.graph import StateGraph, START, END
-
-class ResearchState(TypedDict):
-    topic: str
-    raw_research: str
-    summary: str
-    formatted_output: str
-
-def research_topic(state: ResearchState) -> dict:
-    # Call an LLM or search API
-    result = llm.invoke(f"Research the topic: {state['topic']}")
-    return {"raw_research": result}
-
-def write_summary(state: ResearchState) -> dict:
-    result = llm.invoke(
-        f"Summarize this research:\n{state['raw_research']}"
-    )
-    return {"summary": result}
-
-def format_output(state: ResearchState) -> dict:
-    result = llm.invoke(
-        f"Format this summary as a polished article section:\n{state['summary']}"
-    )
-    return {"formatted_output": result}
-
-# Build the graph
-graph = StateGraph(ResearchState)
-graph.add_node("research", research_topic)
-graph.add_node("summarize", write_summary)
-graph.add_node("format", format_output)
-
-graph.add_edge(START, "research")
-graph.add_edge("research", "summarize")
-graph.add_edge("summarize", "format")
-graph.add_edge("format", END)
-
-# Compile and run
-app = graph.compile()
-result = app.invoke({"topic": "quantum computing advances in 2026"})
-print(result["formatted_output"])
-```
-
-You define functions, register them as nodes, and manually wire every transition. For a simple sequence like this, there's a lot of ceremony.
-
-### CrewAI Flows Approach
-
-```python
-from crewai import LLM, Agent, Crew, Process, Task
-from crewai.flow.flow import Flow, listen, start
-from pydantic import BaseModel
-
-llm = LLM(model="openai/gpt-5.2")
-
-class ResearchState(BaseModel):
-    topic: str = ""
-    raw_research: str = ""
-    summary: str = ""
-    formatted_output: str = ""
-
-class ResearchFlow(Flow[ResearchState]):
-    @start()
-    def research_topic(self):
-        # Option 1: Direct LLM call
-        result = llm.call(f"Research the topic: {self.state.topic}")
-        self.state.raw_research = result
-        return result
-
-    @listen(research_topic)
-    def write_summary(self, research_output):
-        # Option 2: A single agent
-        summarizer = Agent(
-            role="Research Summarizer",
-            goal="Produce concise, accurate summaries of research content",
-            backstory="You are an expert at distilling complex research into clear, "
-            "digestible summaries.",
-            llm=llm,
-            verbose=True,
-        )
-        result = summarizer.kickoff(
-            f"Summarize this research:\n{self.state.raw_research}"
-        )
-        self.state.summary = str(result)
-        return self.state.summary
-
-    @listen(write_summary)
-    def format_output(self, summary_output):
-        # Option 3: a complete crew (with one or more agents)
-        formatter = Agent(
-            role="Content Formatter",
-            goal="Transform research summaries into polished, publication-ready article sections",
-            backstory="You are a skilled editor with expertise in structuring and "
-            "presenting technical content for a general audience.",
-            llm=llm,
-            verbose=True,
-        )
-        format_task = Task(
-            description=f"Format this summary as a polished article section:\n{self.state.summary}",
-            expected_output="A well-structured, polished article section ready for publication.",
-            agent=formatter,
-        )
-        crew = Crew(
-            agents=[formatter],
-            tasks=[format_task],
-            process=Process.sequential,
-            verbose=True,
-        )
-        result = crew.kickoff()
-        self.state.formatted_output = str(result)
-        return self.state.formatted_output
-
-# Run the flow
-flow = ResearchFlow()
-flow.state.topic = "quantum computing advances in 2026"
-result = flow.kickoff()
-print(flow.state.formatted_output)
-
-```
-
-Notice what's different: no graph construction, no edge wiring, no compile step. The execution order is declared right where the logic lives. `@start()` marks the entry point, and `@listen(method_name)` chains steps together. The state is a proper Pydantic model with type safety, validation, and IDE auto-completion.
-
----
-
-## Demo 2: Conditional Routing
-
-This is where things get interesting. Say you're building a content pipeline that routes to different processing paths based on the type of content detected.
-
-### LangGraph Approach
-
-```python
-from typing import TypedDict, Literal
-from langgraph.graph import StateGraph, START, END
-
-class ContentState(TypedDict):
-    input_text: str
-    content_type: str
-    result: str
-
-def classify_content(state: ContentState) -> dict:
-    content_type = llm.invoke(
-        f"Classify this content as 'technical', 'creative', or 'business':\n{state['input_text']}"
-    )
-    return {"content_type": content_type.strip().lower()}
-
-def process_technical(state: ContentState) -> dict:
-    result = llm.invoke(f"Process as technical doc:\n{state['input_text']}")
-    return {"result": result}
-
-def process_creative(state: ContentState) -> dict:
-    result = llm.invoke(f"Process as creative writing:\n{state['input_text']}")
-    return {"result": result}
-
-def process_business(state: ContentState) -> dict:
-    result = llm.invoke(f"Process as business content:\n{state['input_text']}")
-    return {"result": result}
-
-# Routing function
-def route_content(state: ContentState) -> Literal["technical", "creative", "business"]:
-    return state["content_type"]
-
-# Build the graph
-graph = StateGraph(ContentState)
-graph.add_node("classify", classify_content)
-graph.add_node("technical", process_technical)
-graph.add_node("creative", process_creative)
-graph.add_node("business", process_business)
-
-graph.add_edge(START, "classify")
-graph.add_conditional_edges(
-    "classify",
-    route_content,
-    {
-        "technical": "technical",
-        "creative": "creative",
-        "business": "business",
-    }
-)
-graph.add_edge("technical", END)
-graph.add_edge("creative", END)
-graph.add_edge("business", END)
-
-app = graph.compile()
-result = app.invoke({"input_text": "Explain how TCP handshakes work"})
-```
-
-You need a separate routing function, explicit conditional edge mapping, and termination edges for every branch. The routing logic is decoupled from the node that produces the routing decision.
-
-### CrewAI Flows Approach
-
-```python
-from crewai import LLM, Agent
-from crewai.flow.flow import Flow, listen, router, start
-from pydantic import BaseModel
-
-llm = LLM(model="openai/gpt-5.2")
-
-class ContentState(BaseModel):
-    input_text: str = ""
-    content_type: str = ""
-    result: str = ""
-
-class ContentFlow(Flow[ContentState]):
-    @start()
-    def classify_content(self):
-        self.state.content_type = (
-            llm.call(
-                f"Classify this content as 'technical', 'creative', or 'business':\n"
-                f"{self.state.input_text}"
-            )
-            .strip()
-            .lower()
-        )
-        return self.state.content_type
-
-    @router(classify_content)
-    def route_content(self, classification):
-        if classification == "technical":
-            return "process_technical"
-        elif classification == "creative":
-            return "process_creative"
-        else:
-            return "process_business"
-
-    @listen("process_technical")
-    def handle_technical(self):
-        agent = Agent(
-            role="Technical Writer",
-            goal="Produce clear, accurate technical documentation",
-            backstory="You are an expert technical writer who specializes in "
-            "explaining complex technical concepts precisely.",
-            llm=llm,
-            verbose=True,
-        )
-        self.state.result = str(
-            agent.kickoff(f"Process as technical doc:\n{self.state.input_text}")
-        )
-
-    @listen("process_creative")
-    def handle_creative(self):
-        agent = Agent(
-            role="Creative Writer",
-            goal="Craft engaging and imaginative creative content",
-            backstory="You are a talented creative writer with a flair for "
-            "compelling storytelling and vivid expression.",
-            llm=llm,
-            verbose=True,
-        )
-        self.state.result = str(
-            agent.kickoff(f"Process as creative writing:\n{self.state.input_text}")
-        )
-
-    @listen("process_business")
-    def handle_business(self):
-        agent = Agent(
-            role="Business Writer",
-            goal="Produce professional, results-oriented business content",
-            backstory="You are an experienced business writer who communicates "
-            "strategy and value clearly to professional audiences.",
-            llm=llm,
-            verbose=True,
-        )
-        self.state.result = str(
-            agent.kickoff(f"Process as business content:\n{self.state.input_text}")
-        )
-
-flow = ContentFlow()
-flow.state.input_text = "Explain how TCP handshakes work"
-flow.kickoff()
-print(flow.state.result)
-
-```
-
-The `@router()` decorator turns a method into a decision point. It returns a string that matches a listener — no mapping dictionaries, no separate routing functions. The branching logic reads like a Python `if` statement because it *is* one.
-
----
-
-## Demo 3: Integrating AI Agent Crews into Flows
-
-Here's where CrewAI's real power shines. Flows aren't just for chaining LLM calls — they orchestrate full **Crews** of autonomous agents. This is something LangGraph simply doesn't have a native equivalent for.
-
-```python
-from crewai import Agent, Task, Crew
-from crewai.flow.flow import Flow, listen, start
-from pydantic import BaseModel
-
-class ArticleState(BaseModel):
-    topic: str = ""
-    research: str = ""
-    draft: str = ""
-    final_article: str = ""
-
-class ArticleFlow(Flow[ArticleState]):
-
-    @start()
-    def run_research_crew(self):
-        """A full Crew of agents handles research."""
-        researcher = Agent(
-            role="Senior Research Analyst",
-            goal=f"Produce comprehensive research on: {self.state.topic}",
-            backstory="You're a veteran analyst known for thorough, "
-                       "well-sourced research reports.",
-            llm="gpt-4o"
-        )
-
-        research_task = Task(
-            description=f"Research '{self.state.topic}' thoroughly. "
-                        "Cover key trends, data points, and expert opinions.",
-            expected_output="A detailed research brief with sources.",
-            agent=researcher
-        )
-
-        crew = Crew(agents=[researcher], tasks=[research_task])
-        result = crew.kickoff()
-        self.state.research = result.raw
-        return result.raw
-
-    @listen(run_research_crew)
-    def run_writing_crew(self, research_output):
-        """A different Crew handles writing."""
-        writer = Agent(
-            role="Technical Writer",
-            goal="Write a compelling article based on provided research.",
-            backstory="You turn complex research into engaging, clear prose.",
-            llm="gpt-4o"
-        )
-
-        editor = Agent(
-            role="Senior Editor",
-            goal="Review and polish articles for publication quality.",
-            backstory="20 years of editorial experience at top tech publications.",
-            llm="gpt-4o"
-        )
-
-        write_task = Task(
-            description=f"Write an article based on this research:\n{self.state.research}",
-            expected_output="A well-structured draft article.",
-            agent=writer
-        )
-
-        edit_task = Task(
-            description="Review, fact-check, and polish the draft article.",
-            expected_output="A publication-ready article.",
-            agent=editor
-        )
-
-        crew = Crew(agents=[writer, editor], tasks=[write_task, edit_task])
-        result = crew.kickoff()
-        self.state.final_article = result.raw
-        return result.raw
-
-# Run the full pipeline
-flow = ArticleFlow()
-flow.state.topic = "The Future of Edge AI"
-flow.kickoff()
-print(flow.state.final_article)
-```
-
-This is the key insight: **Flows provide the orchestration layer, and Crews provide the intelligence layer.** Each step in a Flow can spin up a full team of collaborating agents, each with their own roles, goals, and tools. You get structured, predictable control flow *and* autonomous agent collaboration — the best of both worlds.
-
-In LangGraph, achieving something similar means manually implementing agent communication protocols, tool-calling loops, and delegation logic inside your node functions. It's possible, but it's plumbing you're building from scratch every time.
-
----
-
-## Demo 4: Parallel Execution and Synchronization
-
-Real-world pipelines often need to fan out work and join the results. CrewAI Flows handles this elegantly with `and_` and `or_` operators.
-
-```python
-from crewai import LLM
-from crewai.flow.flow import Flow, and_, listen, start
-from pydantic import BaseModel
-
-llm = LLM(model="openai/gpt-5.2")
-
-class AnalysisState(BaseModel):
-    topic: str = ""
-    market_data: str = ""
-    tech_analysis: str = ""
-    competitor_intel: str = ""
-    final_report: str = ""
-
-class ParallelAnalysisFlow(Flow[AnalysisState]):
-    @start()
-    def start_method(self):
-        pass
-
-    @listen(start_method)
-    def gather_market_data(self):
-        # Your agentic or deterministic code
-        pass
-
-    @listen(start_method)
-    def run_tech_analysis(self):
-        # Your agentic or deterministic code
-        pass
-
-    @listen(start_method)
-    def gather_competitor_intel(self):
-        # Your agentic or deterministic code
-        pass
-
-    @listen(and_(gather_market_data, run_tech_analysis, gather_competitor_intel))
-    def synthesize_report(self):
-        # Your agentic or deterministic code
-        pass
-
-flow = ParallelAnalysisFlow()
-flow.state.topic = "AI-powered developer tools"
-flow.kickoff()
-
-```
-
-Multiple `@start()` decorators fire in parallel. The `and_()` combinator on the `@listen` decorator ensures `synthesize_report` only executes after *all three* upstream methods complete. There's also `or_()` for when you want to proceed as soon as *any* upstream task finishes.
-
-In LangGraph, you'd need to build a fan-out/fan-in pattern with parallel branches, a synchronization node, and careful state merging — all wired explicitly through edges.
-
----
-
-## Why CrewAI Flows for Production
-
-Beyond cleaner syntax, Flows deliver several production-critical advantages:
-
-**Built-in state persistence.** Flow state is backed by LanceDB, meaning your workflows can survive crashes, be resumed, and accumulate knowledge across runs. LangGraph requires you to configure a separate checkpointer.
-
-**Type-safe state management.** Pydantic models give you validation, serialization, and IDE support out of the box. LangGraph's `TypedDict` states don't validate at runtime.
-
-**First-class agent orchestration.** Crews are a native primitive. You define agents with roles, goals, backstories, and tools — and they collaborate autonomously within the structured envelope of a Flow. No need to reinvent multi-agent coordination.
-
-**Simpler mental model.** Decorators declare intent. `@start` means "begin here." `@listen(x)` means "run after x." `@router(x)` means "decide where to go after x." The code reads like the workflow it describes.
-
-**CLI integration.** Run flows with `crewai run`. No separate compilation step, no graph serialization. Your Flow is a Python class, and it runs like one.
-
----
-
-## Migration Cheat Sheet
-
-If you're sitting on a LangGraph codebase and want to move to CrewAI Flows, here's a practical conversion guide:
-
-1. **Map your state.** Convert your `TypedDict` to a Pydantic `BaseModel`. Add default values for all fields.
-2. **Convert nodes to methods.** Each `add_node` function becomes a method on your `Flow` subclass. Replace `state["field"]` reads with `self.state.field`.
-3. **Replace edges with decorators.** Your `add_edge(START, "first_node")` becomes `@start()` on the first method. Sequential `add_edge("a", "b")` becomes `@listen(a)` on method `b`.
-4. **Replace conditional edges with `@router`.** Your routing function and `add_conditional_edges()` mapping become a single `@router()` method that returns a route string.
-5. **Replace compile + invoke with kickoff.** Drop `graph.compile()`. Call `flow.kickoff()` instead.
-6. **Consider where Crews fit.** Any node where you have complex multi-step agent logic is a candidate for extraction into a Crew. This is where you'll see the biggest quality improvement.
-
----
-
-## Getting Started
-
-Install CrewAI and scaffold a new Flow project:
-
-```bash
-pip install crewai
-crewai create flow my_first_flow
-cd my_first_flow
-```
-
-This generates a project structure with a ready-to-edit Flow class, configuration files, and a `pyproject.toml` with `type = "flow"` already set. Run it with:
-
-```bash
-crewai run
-```
-
-From there, add your agents, wire up your listeners, and ship it.
-
----
-
-## Final Thoughts
-
-LangGraph taught the ecosystem that AI workflows need structure. That was an important lesson. But CrewAI Flows takes that lesson and delivers it in a form that's faster to write, easier to read, and more powerful in production — especially when your workflows involve multiple collaborating agents.
-
-If you're building anything beyond a single-agent chain, give Flows a serious look. The decorator-driven model, native Crew integration, and built-in state management mean you'll spend less time on plumbing and more time on the problems that matter.
-
-Start with `crewai create flow`. You won't look back.

docs/en/tools/automation/composiotool.mdx

@@ -18,46 +18,77 @@ Composio is an integration platform that allows you to connect your AI agents to
 To incorporate Composio tools into your project, follow the instructions below:
 
 ```shell
-pip install composio composio-crewai
+pip install composio-crewai
 pip install crewai
 ```
 
-After the installation is complete, set your Composio API key as `COMPOSIO_API_KEY`. Get your Composio API key from [here](https://platform.composio.dev)
+After the installation is complete, either run `composio login` or export your composio API key as `COMPOSIO_API_KEY`. Get your Composio API key from [here](https://app.composio.dev)
 
 ## Example
 
 The following example demonstrates how to initialize the tool and execute a github action:
 
-1. Initialize Composio with CrewAI Provider
+1. Initialize Composio toolset
 
 ```python Code
-from composio_crewai import ComposioProvider
-from composio import Composio
+from composio_crewai import ComposioToolSet, App, Action
 from crewai import Agent, Task, Crew
 
-composio = Composio(provider=ComposioProvider())
+toolset = ComposioToolSet()
 ```
 
-2. Create a new Composio Session and retrieve the tools
+2. Connect your GitHub account
 <CodeGroup>
-```python
-session = composio.create(
-    user_id="your-user-id",
-    toolkits=["gmail", "github"] # optional, default is all toolkits
-)
-tools = session.tools()
+```shell CLI
+composio add github
+```
+```python Code
+request = toolset.initiate_connection(app=App.GITHUB)
+print(f"Open this URL to authenticate: {request.redirectUrl}")
 ```
-Read more about sessions and user management [here](https://docs.composio.dev/docs/configuring-sessions)
 </CodeGroup>
 
-3. Authenticating users manually
+3. Get Tools
 
-Composio automatically authenticates the users during the agent chat session. However, you can also authenticate the user manually by calling the `authorize` method.
+- Retrieving all the tools from an app (not recommended for production):
 ```python Code
-connection_request = session.authorize("github")
-print(f"Open this URL to authenticate: {connection_request.redirect_url}")
+tools = toolset.get_tools(apps=[App.GITHUB])
 ```
 
+- Filtering tools based on tags:
+```python Code
+tag = "users"
+
+filtered_action_enums = toolset.find_actions_by_tags(
+    App.GITHUB,
+    tags=[tag], 
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+
+- Filtering tools based on use case:
+```python Code
+use_case = "Star a repository on GitHub"
+
+filtered_action_enums = toolset.find_actions_by_use_case(
+    App.GITHUB, use_case=use_case, advanced=False
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+<Tip>Set `advanced` to True to get actions for complex use cases</Tip>
+
+- Using specific tools:
+
+In this demo, we will use the `GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER` action from the GitHub app.
+```python Code
+tools = toolset.get_tools(
+    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
+)
+```
+Learn more about filtering actions [here](https://docs.composio.dev/patterns/tools/use-tools/use-specific-actions)
+
 4. Define agent
 
 ```python Code
@@ -85,4 +116,4 @@ crew = Crew(agents=[crewai_agent], tasks=[task])
 crew.kickoff()
 ```
 
-* More detailed list of tools can be found [here](https://docs.composio.dev/toolkits)
+* More detailed list of tools can be found [here](https://app.composio.dev)

docs/ko/changelog.mdx

@@ -4,88 +4,6 @@ description: "CrewAI의 제품 업데이트, 개선 사항 및 버그 수정"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="2026년 3월 4일">
-  ## v1.10.1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1)
-
-  ## 변경 사항
-
-  ### 기능
-  - Gemini GenAI 업그레이드
-
-  ### 버그 수정
-  - 재귀를 피하기 위해 실행기 리스너 값을 조정
-  - Gemini에서 병렬 함수 응답 부분을 단일 Content 객체로 그룹화
-  - Gemini에서 사고 모델의 사고 출력을 표시
-  - 에이전트 도구가 None일 때 MCP 및 플랫폼 도구 로드
-  - A2A에서 실행 이벤트 루프가 있는 Jupyter 환경 지원
-  - 일시적인 추적을 위해 익명 ID 사용
-  - 조건부로 플러스 헤더 전달
-  - 원격 측정을 위해 비주 스레드에서 신호 처리기 등록 건너뛰기
-  - 도구 오류를 관찰로 주입하고 이름 충돌 해결
-  - Dependabot 경고를 해결하기 위해 pypdf를 4.x에서 6.7.4로 업그레이드
-  - 심각 및 높은 Dependabot 보안 경고 해결
-
-  ### 문서
-  - Composio 도구 문서를 지역별로 동기화
-
-  ## 기여자
-
-  @giulio-leone, @greysonlalonde, @haxzie, @joaomdmoura, @lorenzejay, @mattatcha, @mplachta, @nicoferdi96
-
-</Update>
-
-<Update label="2026년 2월 27일">
-  ## v1.10.1a1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## 변경 사항
-
-  ### 기능
-  - 단계 콜백 메서드에서 비동기 호출 지원 구현
-  - 메모리 모듈의 무거운 의존성에 대한 지연 로딩 구현
-
-  ### 문서
-  - v1.10.0에 대한 변경 로그 및 버전 업데이트
-
-  ### 리팩토링
-  - 비동기 호출을 지원하기 위해 단계 콜백 메서드 리팩토링
-  - 메모리 모듈의 무거운 의존성에 대한 지연 로딩을 구현하기 위해 리팩토링
-
-  ### 버그 수정
-  - 릴리스 노트의 분기 수정
-
-  ## 기여자
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="2026년 2월 27일">
-  ## v1.10.1a1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## 변경 사항
-
-  ### 리팩토링
-  - 비동기 호출을 지원하기 위해 단계 콜백 메서드 리팩토링
-  - 메모리 모듈의 무거운 의존성에 대해 지연 로딩 구현
-
-  ### 문서화
-  - v1.10.0에 대한 변경 로그 및 버전 업데이트
-
-  ### 버그 수정
-  - 릴리스 노트를 위한 브랜치 생성
-
-  ## 기여자
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
 <Update label="2026년 2월 26일">
   ## v1.10.0
 

docs/ko/guides/migration/migrating-from-langgraph.mdx

@@ -1,518 +0,0 @@
----
-title: "LangGraph에서 CrewAI로 옮기기: 엔지니어를 위한 실전 가이드"
-description: LangGraph로 이미 구축했다면, 프로젝트를 CrewAI로 빠르게 옮기는 방법을 알아보세요
-icon: switch
-mode: "wide"
----
-
-LangGraph로 에이전트를 구축해 왔습니다. `StateGraph`와 씨름하고, 조건부 에지를 연결하고, 새벽 2시에 상태 딕셔너리를 디버깅해 본 적도 있죠. 동작은 하지만 — 어느 순간부터 프로덕션으로 가는 더 나은 길이 없을까 고민하게 됩니다.
-
-있습니다. **CrewAI Flows**는 이벤트 기반 오케스트레이션, 조건부 라우팅, 공유 상태라는 동일한 힘을 훨씬 적은 보일러플레이트와 실제로 다단계 AI 워크플로우를 생각하는 방식에 잘 맞는 정신적 모델로 제공합니다.
-
-이 글은 핵심 개념을 나란히 비교하고 실제 코드 비교를 보여주며, 다음으로 손이 갈 프레임워크가 왜 CrewAI Flows인지 설명합니다.
-
----
-
-## 정신적 모델의 전환
-
-LangGraph는 **그래프**로 생각하라고 요구합니다: 노드, 에지, 그리고 상태 딕셔너리. 모든 워크플로우는 계산 단계 사이의 전이를 명시적으로 연결하는 방향 그래프입니다. 강력하지만, 특히 워크플로우가 몇 개의 결정 지점이 있는 순차적 흐름일 때 이 추상화는 오버헤드를 가져옵니다.
-
-CrewAI Flows는 **이벤트**로 생각하라고 요구합니다: 시작하는 메서드, 결과를 듣는 메서드, 실행을 라우팅하는 메서드. 워크플로우의 토폴로지는 명시적 그래프 구성 대신 데코레이터 어노테이션에서 드러납니다. 이것은 단순한 문법 설탕이 아니라 — 파이프라인을 설계하고 읽고 유지하는 방식을 바꿉니다.
-
-핵심 매핑은 다음과 같습니다:
-
-| LangGraph 개념 | CrewAI Flows 대응 |
-| --- | --- |
-| `StateGraph` class | `Flow` class |
-| `add_node()` | Methods decorated with `@start`, `@listen` |
-| `add_edge()` / `add_conditional_edges()` | `@listen()` / `@router()` decorators |
-| `TypedDict` state | Pydantic `BaseModel` state |
-| `START` / `END` constants | `@start()` decorator / natural method return |
-| `graph.compile()` | `flow.kickoff()` |
-| Checkpointer / persistence | Built-in memory (LanceDB-backed) |
-
-실제로 어떻게 보이는지 살펴보겠습니다.
-
----
-
-## 데모 1: 간단한 순차 파이프라인
-
-주제를 받아 조사하고, 요약을 작성한 뒤, 결과를 포맷팅하는 파이프라인을 만든다고 해봅시다. 각 프레임워크는 이렇게 처리합니다.
-
-### LangGraph 방식
-
-```python
-from typing import TypedDict
-from langgraph.graph import StateGraph, START, END
-
-class ResearchState(TypedDict):
-    topic: str
-    raw_research: str
-    summary: str
-    formatted_output: str
-
-def research_topic(state: ResearchState) -> dict:
-    # Call an LLM or search API
-    result = llm.invoke(f"Research the topic: {state['topic']}")
-    return {"raw_research": result}
-
-def write_summary(state: ResearchState) -> dict:
-    result = llm.invoke(
-        f"Summarize this research:\n{state['raw_research']}"
-    )
-    return {"summary": result}
-
-def format_output(state: ResearchState) -> dict:
-    result = llm.invoke(
-        f"Format this summary as a polished article section:\n{state['summary']}"
-    )
-    return {"formatted_output": result}
-
-# Build the graph
-graph = StateGraph(ResearchState)
-graph.add_node("research", research_topic)
-graph.add_node("summarize", write_summary)
-graph.add_node("format", format_output)
-
-graph.add_edge(START, "research")
-graph.add_edge("research", "summarize")
-graph.add_edge("summarize", "format")
-graph.add_edge("format", END)
-
-# Compile and run
-app = graph.compile()
-result = app.invoke({"topic": "quantum computing advances in 2026"})
-print(result["formatted_output"])
-```
-
-함수를 정의하고 노드로 등록한 다음, 모든 전이를 수동으로 연결합니다. 이렇게 단순한 순서인데도 의례처럼 해야 할 작업이 많습니다.
-
-### CrewAI Flows 방식
-
-```python
-from crewai import LLM, Agent, Crew, Process, Task
-from crewai.flow.flow import Flow, listen, start
-from pydantic import BaseModel
-
-llm = LLM(model="openai/gpt-5.2")
-
-class ResearchState(BaseModel):
-    topic: str = ""
-    raw_research: str = ""
-    summary: str = ""
-    formatted_output: str = ""
-
-class ResearchFlow(Flow[ResearchState]):
-    @start()
-    def research_topic(self):
-        # Option 1: Direct LLM call
-        result = llm.call(f"Research the topic: {self.state.topic}")
-        self.state.raw_research = result
-        return result
-
-    @listen(research_topic)
-    def write_summary(self, research_output):
-        # Option 2: A single agent
-        summarizer = Agent(
-            role="Research Summarizer",
-            goal="Produce concise, accurate summaries of research content",
-            backstory="You are an expert at distilling complex research into clear, "
-            "digestible summaries.",
-            llm=llm,
-            verbose=True,
-        )
-        result = summarizer.kickoff(
-            f"Summarize this research:\n{self.state.raw_research}"
-        )
-        self.state.summary = str(result)
-        return self.state.summary
-
-    @listen(write_summary)
-    def format_output(self, summary_output):
-        # Option 3: a complete crew (with one or more agents)
-        formatter = Agent(
-            role="Content Formatter",
-            goal="Transform research summaries into polished, publication-ready article sections",
-            backstory="You are a skilled editor with expertise in structuring and "
-            "presenting technical content for a general audience.",
-            llm=llm,
-            verbose=True,
-        )
-        format_task = Task(
-            description=f"Format this summary as a polished article section:\n{self.state.summary}",
-            expected_output="A well-structured, polished article section ready for publication.",
-            agent=formatter,
-        )
-        crew = Crew(
-            agents=[formatter],
-            tasks=[format_task],
-            process=Process.sequential,
-            verbose=True,
-        )
-        result = crew.kickoff()
-        self.state.formatted_output = str(result)
-        return self.state.formatted_output
-
-# Run the flow
-flow = ResearchFlow()
-flow.state.topic = "quantum computing advances in 2026"
-result = flow.kickoff()
-print(flow.state.formatted_output)
-
-```
-
-눈에 띄는 차이점이 있습니다: 그래프 구성 없음, 에지 연결 없음, 컴파일 단계 없음. 실행 순서는 로직이 있는 곳에서 바로 선언됩니다. `@start()`는 진입점을 표시하고, `@listen(method_name)`은 단계들을 연결합니다. 상태는 타입 안전성, 검증, IDE 자동 완성까지 제공하는 제대로 된 Pydantic 모델입니다.
-
----
-
-## 데모 2: 조건부 라우팅
-
-여기서 흥미로워집니다. 콘텐츠 유형에 따라 서로 다른 처리 경로로 라우팅하는 파이프라인을 만든다고 해봅시다.
-
-### LangGraph 방식
-
-```python
-from typing import TypedDict, Literal
-from langgraph.graph import StateGraph, START, END
-
-class ContentState(TypedDict):
-    input_text: str
-    content_type: str
-    result: str
-
-def classify_content(state: ContentState) -> dict:
-    content_type = llm.invoke(
-        f"Classify this content as 'technical', 'creative', or 'business':\n{state['input_text']}"
-    )
-    return {"content_type": content_type.strip().lower()}
-
-def process_technical(state: ContentState) -> dict:
-    result = llm.invoke(f"Process as technical doc:\n{state['input_text']}")
-    return {"result": result}
-
-def process_creative(state: ContentState) -> dict:
-    result = llm.invoke(f"Process as creative writing:\n{state['input_text']}")
-    return {"result": result}
-
-def process_business(state: ContentState) -> dict:
-    result = llm.invoke(f"Process as business content:\n{state['input_text']}")
-    return {"result": result}
-
-# Routing function
-def route_content(state: ContentState) -> Literal["technical", "creative", "business"]:
-    return state["content_type"]
-
-# Build the graph
-graph = StateGraph(ContentState)
-graph.add_node("classify", classify_content)
-graph.add_node("technical", process_technical)
-graph.add_node("creative", process_creative)
-graph.add_node("business", process_business)
-
-graph.add_edge(START, "classify")
-graph.add_conditional_edges(
-    "classify",
-    route_content,
-    {
-        "technical": "technical",
-        "creative": "creative",
-        "business": "business",
-    }
-)
-graph.add_edge("technical", END)
-graph.add_edge("creative", END)
-graph.add_edge("business", END)
-
-app = graph.compile()
-result = app.invoke({"input_text": "Explain how TCP handshakes work"})
-```
-
-별도의 라우팅 함수, 명시적 조건부 에지 매핑, 그리고 모든 분기에 대한 종료 에지가 필요합니다. 라우팅 결정 로직이 그 결정을 만들어 내는 노드와 분리됩니다.
-
-### CrewAI Flows 방식
-
-```python
-from crewai import LLM, Agent
-from crewai.flow.flow import Flow, listen, router, start
-from pydantic import BaseModel
-
-llm = LLM(model="openai/gpt-5.2")
-
-class ContentState(BaseModel):
-    input_text: str = ""
-    content_type: str = ""
-    result: str = ""
-
-class ContentFlow(Flow[ContentState]):
-    @start()
-    def classify_content(self):
-        self.state.content_type = (
-            llm.call(
-                f"Classify this content as 'technical', 'creative', or 'business':\n"
-                f"{self.state.input_text}"
-            )
-            .strip()
-            .lower()
-        )
-        return self.state.content_type
-
-    @router(classify_content)
-    def route_content(self, classification):
-        if classification == "technical":
-            return "process_technical"
-        elif classification == "creative":
-            return "process_creative"
-        else:
-            return "process_business"
-
-    @listen("process_technical")
-    def handle_technical(self):
-        agent = Agent(
-            role="Technical Writer",
-            goal="Produce clear, accurate technical documentation",
-            backstory="You are an expert technical writer who specializes in "
-            "explaining complex technical concepts precisely.",
-            llm=llm,
-            verbose=True,
-        )
-        self.state.result = str(
-            agent.kickoff(f"Process as technical doc:\n{self.state.input_text}")
-        )
-
-    @listen("process_creative")
-    def handle_creative(self):
-        agent = Agent(
-            role="Creative Writer",
-            goal="Craft engaging and imaginative creative content",
-            backstory="You are a talented creative writer with a flair for "
-            "compelling storytelling and vivid expression.",
-            llm=llm,
-            verbose=True,
-        )
-        self.state.result = str(
-            agent.kickoff(f"Process as creative writing:\n{self.state.input_text}")
-        )
-
-    @listen("process_business")
-    def handle_business(self):
-        agent = Agent(
-            role="Business Writer",
-            goal="Produce professional, results-oriented business content",
-            backstory="You are an experienced business writer who communicates "
-            "strategy and value clearly to professional audiences.",
-            llm=llm,
-            verbose=True,
-        )
-        self.state.result = str(
-            agent.kickoff(f"Process as business content:\n{self.state.input_text}")
-        )
-
-flow = ContentFlow()
-flow.state.input_text = "Explain how TCP handshakes work"
-flow.kickoff()
-print(flow.state.result)
-
-```
-
-`@router()` 데코레이터는 메서드를 결정 지점으로 만듭니다. 리스너와 매칭되는 문자열을 반환하므로, 매핑 딕셔너리도, 별도의 라우팅 함수도 필요 없습니다. 분기 로직이 Python `if` 문처럼 읽히는 이유는, 실제로 `if` 문이기 때문입니다.
-
----
-
-## 데모 3: AI 에이전트 Crew를 Flow에 통합하기
-
-여기서 CrewAI의 진짜 힘이 드러납니다. Flows는 LLM 호출을 연결하는 것에 그치지 않고 자율적인 에이전트 **Crew** 전체를 오케스트레이션합니다. 이는 LangGraph에 기본으로 대응되는 개념이 없습니다.
-
-```python
-from crewai import Agent, Task, Crew
-from crewai.flow.flow import Flow, listen, start
-from pydantic import BaseModel
-
-class ArticleState(BaseModel):
-    topic: str = ""
-    research: str = ""
-    draft: str = ""
-    final_article: str = ""
-
-class ArticleFlow(Flow[ArticleState]):
-
-    @start()
-    def run_research_crew(self):
-        """A full Crew of agents handles research."""
-        researcher = Agent(
-            role="Senior Research Analyst",
-            goal=f"Produce comprehensive research on: {self.state.topic}",
-            backstory="You're a veteran analyst known for thorough, "
-                       "well-sourced research reports.",
-            llm="gpt-4o"
-        )
-
-        research_task = Task(
-            description=f"Research '{self.state.topic}' thoroughly. "
-                        "Cover key trends, data points, and expert opinions.",
-            expected_output="A detailed research brief with sources.",
-            agent=researcher
-        )
-
-        crew = Crew(agents=[researcher], tasks=[research_task])
-        result = crew.kickoff()
-        self.state.research = result.raw
-        return result.raw
-
-    @listen(run_research_crew)
-    def run_writing_crew(self, research_output):
-        """A different Crew handles writing."""
-        writer = Agent(
-            role="Technical Writer",
-            goal="Write a compelling article based on provided research.",
-            backstory="You turn complex research into engaging, clear prose.",
-            llm="gpt-4o"
-        )
-
-        editor = Agent(
-            role="Senior Editor",
-            goal="Review and polish articles for publication quality.",
-            backstory="20 years of editorial experience at top tech publications.",
-            llm="gpt-4o"
-        )
-
-        write_task = Task(
-            description=f"Write an article based on this research:\n{self.state.research}",
-            expected_output="A well-structured draft article.",
-            agent=writer
-        )
-
-        edit_task = Task(
-            description="Review, fact-check, and polish the draft article.",
-            expected_output="A publication-ready article.",
-            agent=editor
-        )
-
-        crew = Crew(agents=[writer, editor], tasks=[write_task, edit_task])
-        result = crew.kickoff()
-        self.state.final_article = result.raw
-        return result.raw
-
-# Run the full pipeline
-flow = ArticleFlow()
-flow.state.topic = "The Future of Edge AI"
-flow.kickoff()
-print(flow.state.final_article)
-```
-
-핵심 인사이트는 다음과 같습니다: **Flows는 오케스트레이션 레이어를, Crews는 지능 레이어를 제공합니다.** Flow의 각 단계는 각자의 역할, 목표, 도구를 가진 협업 에이전트 팀을 띄울 수 있습니다. 구조화되고 예측 가능한 제어 흐름 *그리고* 자율적 에이전트 협업 — 두 세계의 장점을 모두 얻습니다.
-
-LangGraph에서 비슷한 것을 하려면 노드 함수 안에 에이전트 통신 프로토콜, 도구 호출 루프, 위임 로직을 직접 구현해야 합니다. 가능하긴 하지만, 매번 처음부터 배관을 만드는 셈입니다.
-
----
-
-## 데모 4: 병렬 실행과 동기화
-
-실제 파이프라인은 종종 작업을 병렬로 분기하고 결과를 합쳐야 합니다. CrewAI Flows는 `and_`와 `or_` 연산자로 이를 우아하게 처리합니다.
-
-```python
-from crewai import LLM
-from crewai.flow.flow import Flow, and_, listen, start
-from pydantic import BaseModel
-
-llm = LLM(model="openai/gpt-5.2")
-
-class AnalysisState(BaseModel):
-    topic: str = ""
-    market_data: str = ""
-    tech_analysis: str = ""
-    competitor_intel: str = ""
-    final_report: str = ""
-
-class ParallelAnalysisFlow(Flow[AnalysisState]):
-    @start()
-    def start_method(self):
-        pass
-
-    @listen(start_method)
-    def gather_market_data(self):
-        # Your agentic or deterministic code
-        pass
-
-    @listen(start_method)
-    def run_tech_analysis(self):
-        # Your agentic or deterministic code
-        pass
-
-    @listen(start_method)
-    def gather_competitor_intel(self):
-        # Your agentic or deterministic code
-        pass
-
-    @listen(and_(gather_market_data, run_tech_analysis, gather_competitor_intel))
-    def synthesize_report(self):
-        # Your agentic or deterministic code
-        pass
-
-flow = ParallelAnalysisFlow()
-flow.state.topic = "AI-powered developer tools"
-flow.kickoff()
-
-```
-
-여러 `@start()` 데코레이터는 병렬로 실행됩니다. `@listen` 데코레이터의 `and_()` 결합자는 `synthesize_report`가 *세 가지* 상위 메서드가 모두 완료된 뒤에만 실행되도록 보장합니다. *어떤* 상위 작업이든 끝나는 즉시 진행하고 싶다면 `or_()`도 사용할 수 있습니다.
-
-LangGraph에서는 병렬 분기, 동기화 노드, 신중한 상태 병합이 포함된 fan-out/fan-in 패턴을 만들어야 하며 — 모든 것을 에지로 명시적으로 연결해야 합니다.
-
----
-
-## 프로덕션에서 CrewAI Flows를 쓰는 이유
-
-깔끔한 문법을 넘어, Flows는 여러 프로덕션 핵심 이점을 제공합니다:
-
-**내장 상태 지속성.** Flow 상태는 LanceDB에 의해 백업되므로 워크플로우가 크래시에서 살아남고, 재개될 수 있으며, 실행 간에 지식을 축적할 수 있습니다. LangGraph는 별도의 체크포인터를 구성해야 합니다.
-
-**타입 안전한 상태 관리.** Pydantic 모델은 즉시 검증, 직렬화, IDE 지원을 제공합니다. LangGraph의 `TypedDict` 상태는 런타임 검증을 하지 않습니다.
-
-**일급 에이전트 오케스트레이션.** Crews는 기본 프리미티브입니다. 역할, 목표, 배경, 도구를 가진 에이전트를 정의하고, Flow의 구조적 틀 안에서 자율적으로 협업하게 합니다. 다중 에이전트 조율을 다시 만들 필요가 없습니다.
-
-**더 단순한 정신적 모델.** 데코레이터는 의도를 선언합니다. `@start`는 "여기서 시작", `@listen(x)`는 "x 이후 실행", `@router(x)`는 "x 이후 어디로 갈지 결정"을 의미합니다. 코드는 자신이 설명하는 워크플로우처럼 읽힙니다.
-
-**CLI 통합.** `crewai run`으로 Flows를 실행합니다. 별도의 컴파일 단계나 그래프 직렬화가 없습니다. Flow는 Python 클래스이며, 그대로 실행됩니다.
-
----
-
-## 마이그레이션 치트 시트
-
-LangGraph 코드베이스를 CrewAI Flows로 옮기고 싶다면, 다음의 실전 변환 가이드를 참고하세요:
-
-1. **상태를 매핑하세요.** `TypedDict`를 Pydantic `BaseModel`로 변환하고 모든 필드에 기본값을 추가하세요.
-2. **노드를 메서드로 변환하세요.** 각 `add_node` 함수는 `Flow` 서브클래스의 메서드가 됩니다. `state["field"]` 읽기는 `self.state.field`로 바꾸세요.
-3. **에지를 데코레이터로 교체하세요.** `add_edge(START, "first_node")`는 첫 메서드의 `@start()`가 됩니다. 순차적인 `add_edge("a", "b")`는 `b` 메서드의 `@listen(a)`가 됩니다.
-4. **조건부 에지는 `@router`로 교체하세요.** 라우팅 함수와 `add_conditional_edges()` 매핑은 하나의 `@router()` 메서드로 통합하고, 라우트 문자열을 반환하세요.
-5. **compile + invoke를 kickoff으로 교체하세요.** `graph.compile()`를 제거하고 `flow.kickoff()`를 호출하세요.
-6. **Crew가 들어갈 지점을 고려하세요.** 복잡한 다단계 에이전트 로직이 있는 노드는 Crew로 분리할 후보입니다. 이 부분에서 가장 큰 품질 향상을 체감할 수 있습니다.
-
----
-
-## 시작하기
-
-CrewAI를 설치하고 새 Flow 프로젝트를 스캐폴딩하세요:
-
-```bash
-pip install crewai
-crewai create flow my_first_flow
-cd my_first_flow
-```
-
-이렇게 하면 바로 편집 가능한 Flow 클래스, 설정 파일, 그리고 `type = "flow"`가 이미 설정된 `pyproject.toml`이 포함된 프로젝트 구조가 생성됩니다. 다음으로 실행하세요:
-
-```bash
-crewai run
-```
-
-그 다음부터는 에이전트를 추가하고 리스너를 연결한 뒤, 배포하면 됩니다.
-
----
-
-## 마무리
-
-LangGraph는 AI 워크플로우에 구조가 필요하다는 사실을 생태계에 일깨워 주었습니다. 중요한 교훈이었습니다. 하지만 CrewAI Flows는 그 교훈을 더 빠르게 쓰고, 더 쉽게 읽으며, 프로덕션에서 더 강력한 형태로 제공합니다 — 특히 워크플로우에 여러 에이전트의 협업이 포함될 때 그렇습니다.
-
-단일 에이전트 체인을 넘는 무엇인가를 만들고 있다면, Flows를 진지하게 검토해 보세요. 데코레이터 기반 모델, Crews의 네이티브 통합, 내장 상태 관리를 통해 배관 작업에 쓰는 시간을 줄이고, 중요한 문제에 더 많은 시간을 쓸 수 있습니다.
-
-`crewai create flow`로 시작하세요. 후회하지 않을 겁니다.

docs/ko/tools/automation/composiotool.mdx

@@ -18,46 +18,77 @@ Composio는 AI 에이전트를 250개 이상의 도구와 연결할 수 있는
 Composio 도구를 프로젝트에 통합하려면 아래 지침을 따르세요:
 
 ```shell
-pip install composio composio-crewai
+pip install composio-crewai
 pip install crewai
 ```
 
-설치가 완료되면 Composio API 키를 `COMPOSIO_API_KEY`로 설정하세요. Composio API 키는 [여기](https://platform.composio.dev)에서 받을 수 있습니다.
+설치가 완료된 후, `composio login`을 실행하거나 Composio API 키를 `COMPOSIO_API_KEY`로 export하세요. Composio API 키는 [여기](https://app.composio.dev)에서 받을 수 있습니다.
 
 ## 예시
 
-다음 예시는 도구를 초기화하고 GitHub 액션을 실행하는 방법을 보여줍니다:
+다음 예시는 도구를 초기화하고 github action을 실행하는 방법을 보여줍니다:
 
-1. CrewAI Provider와 함께 Composio 초기화
+1. Composio 도구 세트 초기화
 
 ```python Code
-from composio_crewai import ComposioProvider
-from composio import Composio
+from composio_crewai import ComposioToolSet, App, Action
 from crewai import Agent, Task, Crew
 
-composio = Composio(provider=ComposioProvider())
+toolset = ComposioToolSet()
 ```
 
-2. 새 Composio 세션을 만들고 도구 가져오기
+2. GitHub 계정 연결
 <CodeGroup>
-```python
-session = composio.create(
-    user_id="your-user-id",
-    toolkits=["gmail", "github"] # optional, default is all toolkits
-)
-tools = session.tools()
+```shell CLI
+composio add github
+```
+```python Code
+request = toolset.initiate_connection(app=App.GITHUB)
+print(f"Open this URL to authenticate: {request.redirectUrl}")
 ```
-세션 및 사용자 관리에 대한 자세한 내용은 [여기](https://docs.composio.dev/docs/configuring-sessions)를 참고하세요.
 </CodeGroup>
 
-3. 사용자 수동 인증하기
+3. 도구 가져오기
 
-Composio는 에이전트 채팅 세션 중에 사용자를 자동으로 인증합니다. 하지만 `authorize` 메서드를 호출해 사용자를 수동으로 인증할 수도 있습니다.
+- 앱에서 모든 도구를 가져오기 (프로덕션 환경에서는 권장하지 않음):
 ```python Code
-connection_request = session.authorize("github")
-print(f"Open this URL to authenticate: {connection_request.redirect_url}")
+tools = toolset.get_tools(apps=[App.GITHUB])
 ```
 
+- 태그를 기반으로 도구 필터링:
+```python Code
+tag = "users"
+
+filtered_action_enums = toolset.find_actions_by_tags(
+    App.GITHUB,
+    tags=[tag], 
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+
+- 사용 사례를 기반으로 도구 필터링:
+```python Code
+use_case = "Star a repository on GitHub"
+
+filtered_action_enums = toolset.find_actions_by_use_case(
+    App.GITHUB, use_case=use_case, advanced=False
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+<Tip>`advanced`를 True로 설정하면 복잡한 사용 사례를 위한 액션을 가져올 수 있습니다</Tip>
+
+- 특정 도구 사용하기:
+
+이 데모에서는 GitHub 앱의 `GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER` 액션을 사용합니다.
+```python Code
+tools = toolset.get_tools(
+    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
+)
+```
+액션 필터링에 대해 더 자세한 내용을 보려면 [여기](https://docs.composio.dev/patterns/tools/use-tools/use-specific-actions)를 참고하세요.
+
 4. 에이전트 정의
 
 ```python Code
@@ -85,4 +116,4 @@ crew = Crew(agents=[crewai_agent], tasks=[task])
 crew.kickoff()
 ```
 
-* 더욱 자세한 도구 목록은 [여기](https://docs.composio.dev/toolkits)에서 확인할 수 있습니다.
+* 더욱 자세한 도구 리스트는 [여기](https://app.composio.dev)에서 확인하실 수 있습니다.

docs/pt-BR/changelog.mdx

@@ -4,88 +4,6 @@ description: "Atualizações de produto, melhorias e correções do CrewAI"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="04 mar 2026">
-  ## v1.10.1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1)
-
-  ## O que mudou
-
-  ### Recursos
-  - Atualizar Gemini GenAI
-
-  ### Correções de Bugs
-  - Ajustar o valor do listener do executor para evitar recursão
-  - Agrupar partes da resposta da função paralela em um único objeto Content no Gemini
-  - Exibir a saída de pensamento dos modelos de pensamento no Gemini
-  - Carregar ferramentas MCP e da plataforma quando as ferramentas do agente forem None
-  - Suportar ambientes Jupyter com loops de eventos em A2A
-  - Usar ID anônimo para rastreamentos efêmeros
-  - Passar condicionalmente o cabeçalho plus
-  - Ignorar o registro do manipulador de sinal em threads não principais para telemetria
-  - Injetar erros de ferramentas como observações e resolver colisões de nomes
-  - Atualizar pypdf de 4.x para 6.7.4 para resolver alertas do Dependabot
-  - Resolver alertas de segurança críticos e altos do Dependabot
-
-  ### Documentação
-  - Sincronizar a documentação da ferramenta Composio entre locais
-
-  ## Contribuidores
-
-  @giulio-leone, @greysonlalonde, @haxzie, @joaomdmoura, @lorenzejay, @mattatcha, @mplachta, @nicoferdi96
-
-</Update>
-
-<Update label="27 fev 2026">
-  ## v1.10.1a1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## O que Mudou
-
-  ### Funcionalidades
-  - Implementar suporte a invocação assíncrona em métodos de callback de etapas
-  - Implementar carregamento sob demanda para dependências pesadas no módulo de Memória
-
-  ### Documentação
-  - Atualizar changelog e versão para v1.10.0
-
-  ### Refatoração
-  - Refatorar métodos de callback de etapas para suportar invocação assíncrona
-  - Refatorar para implementar carregamento sob demanda para dependências pesadas no módulo de Memória
-
-  ### Correções de Bugs
-  - Corrigir branch para notas de lançamento
-
-  ## Contribuidores
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="27 fev 2026">
-  ## v1.10.1a1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## O que Mudou
-
-  ### Refatoração
-  - Refatorar métodos de callback de etapas para suportar invocação assíncrona
-  - Implementar carregamento sob demanda para dependências pesadas no módulo de Memória
-
-  ### Documentação
-  - Atualizar changelog e versão para v1.10.0
-
-  ### Correções de Bugs
-  - Criar branch para notas de lançamento
-
-  ## Contribuidores
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
 <Update label="26 fev 2026">
   ## v1.10.0
 

docs/pt-BR/guides/migration/migrating-from-langgraph.mdx

@@ -1,518 +0,0 @@
----
-title: "Migrando do LangGraph para o CrewAI: um guia prático para engenheiros"
-description: Se você já construiu com LangGraph, saiba como portar rapidamente seus projetos para o CrewAI
-icon: switch
-mode: "wide"
----
-
-Você construiu agentes com LangGraph. Já lutou com o `StateGraph`, ligou arestas condicionais e depurou dicionários de estado às 2 da manhã. Funciona — mas, em algum momento, você começou a se perguntar se existe um caminho melhor para produção.
-
-Existe. **CrewAI Flows** entrega o mesmo poder — orquestração orientada a eventos, roteamento condicional, estado compartilhado — com muito menos boilerplate e um modelo mental que se alinha a como você realmente pensa sobre fluxos de trabalho de IA em múltiplas etapas.
-
-Este artigo apresenta os conceitos principais lado a lado, mostra comparações reais de código e demonstra por que o CrewAI Flows é o framework que você vai querer usar a seguir.
-
----
-
-## A Mudança de Modelo Mental
-
-LangGraph pede que você pense em **grafos**: nós, arestas e dicionários de estado. Todo workflow é um grafo direcionado em que você conecta explicitamente as transições entre as etapas de computação. É poderoso, mas a abstração traz overhead — especialmente quando o seu fluxo é fundamentalmente sequencial com alguns pontos de decisão.
-
-CrewAI Flows pede que você pense em **eventos**: métodos que iniciam, métodos que escutam resultados e métodos que roteiam a execução. A topologia do workflow emerge de anotações com decorators, em vez de construção explícita do grafo. Isso não é apenas açúcar sintático — muda como você projeta, lê e mantém seus pipelines.
-
-Veja o mapeamento principal:
-
-| Conceito no LangGraph | Equivalente no CrewAI Flows |
-| --- | --- |
-| `StateGraph` class | `Flow` class |
-| `add_node()` | Methods decorated with `@start`, `@listen` |
-| `add_edge()` / `add_conditional_edges()` | `@listen()` / `@router()` decorators |
-| `TypedDict` state | Pydantic `BaseModel` state |
-| `START` / `END` constants | `@start()` decorator / natural method return |
-| `graph.compile()` | `flow.kickoff()` |
-| Checkpointer / persistence | Built-in memory (LanceDB-backed) |
-
-Vamos ver como isso fica na prática.
-
----
-
-## Demo 1: Um Pipeline Sequencial Simples
-
-Imagine que você está construindo um pipeline que recebe um tema, pesquisa, escreve um resumo e formata a saída. Veja como cada framework lida com isso.
-
-### Abordagem com LangGraph
-
-```python
-from typing import TypedDict
-from langgraph.graph import StateGraph, START, END
-
-class ResearchState(TypedDict):
-    topic: str
-    raw_research: str
-    summary: str
-    formatted_output: str
-
-def research_topic(state: ResearchState) -> dict:
-    # Call an LLM or search API
-    result = llm.invoke(f"Research the topic: {state['topic']}")
-    return {"raw_research": result}
-
-def write_summary(state: ResearchState) -> dict:
-    result = llm.invoke(
-        f"Summarize this research:\n{state['raw_research']}"
-    )
-    return {"summary": result}
-
-def format_output(state: ResearchState) -> dict:
-    result = llm.invoke(
-        f"Format this summary as a polished article section:\n{state['summary']}"
-    )
-    return {"formatted_output": result}
-
-# Build the graph
-graph = StateGraph(ResearchState)
-graph.add_node("research", research_topic)
-graph.add_node("summarize", write_summary)
-graph.add_node("format", format_output)
-
-graph.add_edge(START, "research")
-graph.add_edge("research", "summarize")
-graph.add_edge("summarize", "format")
-graph.add_edge("format", END)
-
-# Compile and run
-app = graph.compile()
-result = app.invoke({"topic": "quantum computing advances in 2026"})
-print(result["formatted_output"])
-```
-
-Você define funções, registra-as como nós e conecta manualmente cada transição. Para uma sequência simples como essa, há muita cerimônia.
-
-### Abordagem com CrewAI Flows
-
-```python
-from crewai import LLM, Agent, Crew, Process, Task
-from crewai.flow.flow import Flow, listen, start
-from pydantic import BaseModel
-
-llm = LLM(model="openai/gpt-5.2")
-
-class ResearchState(BaseModel):
-    topic: str = ""
-    raw_research: str = ""
-    summary: str = ""
-    formatted_output: str = ""
-
-class ResearchFlow(Flow[ResearchState]):
-    @start()
-    def research_topic(self):
-        # Option 1: Direct LLM call
-        result = llm.call(f"Research the topic: {self.state.topic}")
-        self.state.raw_research = result
-        return result
-
-    @listen(research_topic)
-    def write_summary(self, research_output):
-        # Option 2: A single agent
-        summarizer = Agent(
-            role="Research Summarizer",
-            goal="Produce concise, accurate summaries of research content",
-            backstory="You are an expert at distilling complex research into clear, "
-            "digestible summaries.",
-            llm=llm,
-            verbose=True,
-        )
-        result = summarizer.kickoff(
-            f"Summarize this research:\n{self.state.raw_research}"
-        )
-        self.state.summary = str(result)
-        return self.state.summary
-
-    @listen(write_summary)
-    def format_output(self, summary_output):
-        # Option 3: a complete crew (with one or more agents)
-        formatter = Agent(
-            role="Content Formatter",
-            goal="Transform research summaries into polished, publication-ready article sections",
-            backstory="You are a skilled editor with expertise in structuring and "
-            "presenting technical content for a general audience.",
-            llm=llm,
-            verbose=True,
-        )
-        format_task = Task(
-            description=f"Format this summary as a polished article section:\n{self.state.summary}",
-            expected_output="A well-structured, polished article section ready for publication.",
-            agent=formatter,
-        )
-        crew = Crew(
-            agents=[formatter],
-            tasks=[format_task],
-            process=Process.sequential,
-            verbose=True,
-        )
-        result = crew.kickoff()
-        self.state.formatted_output = str(result)
-        return self.state.formatted_output
-
-# Run the flow
-flow = ResearchFlow()
-flow.state.topic = "quantum computing advances in 2026"
-result = flow.kickoff()
-print(flow.state.formatted_output)
-
-```
-
-Repare a diferença: nada de construção de grafo, de ligação de arestas, nem de etapa de compilação. A ordem de execução é declarada exatamente onde a lógica vive. `@start()` marca o ponto de entrada, e `@listen(method_name)` encadeia as etapas. O estado é um modelo Pydantic de verdade, com segurança de tipos, validação e auto-complete na IDE.
-
----
-
-## Demo 2: Roteamento Condicional
-
-Aqui é que fica interessante. Digamos que você está construindo um pipeline de conteúdo que roteia para diferentes caminhos de processamento com base no tipo de conteúdo detectado.
-
-### Abordagem com LangGraph
-
-```python
-from typing import TypedDict, Literal
-from langgraph.graph import StateGraph, START, END
-
-class ContentState(TypedDict):
-    input_text: str
-    content_type: str
-    result: str
-
-def classify_content(state: ContentState) -> dict:
-    content_type = llm.invoke(
-        f"Classify this content as 'technical', 'creative', or 'business':\n{state['input_text']}"
-    )
-    return {"content_type": content_type.strip().lower()}
-
-def process_technical(state: ContentState) -> dict:
-    result = llm.invoke(f"Process as technical doc:\n{state['input_text']}")
-    return {"result": result}
-
-def process_creative(state: ContentState) -> dict:
-    result = llm.invoke(f"Process as creative writing:\n{state['input_text']}")
-    return {"result": result}
-
-def process_business(state: ContentState) -> dict:
-    result = llm.invoke(f"Process as business content:\n{state['input_text']}")
-    return {"result": result}
-
-# Routing function
-def route_content(state: ContentState) -> Literal["technical", "creative", "business"]:
-    return state["content_type"]
-
-# Build the graph
-graph = StateGraph(ContentState)
-graph.add_node("classify", classify_content)
-graph.add_node("technical", process_technical)
-graph.add_node("creative", process_creative)
-graph.add_node("business", process_business)
-
-graph.add_edge(START, "classify")
-graph.add_conditional_edges(
-    "classify",
-    route_content,
-    {
-        "technical": "technical",
-        "creative": "creative",
-        "business": "business",
-    }
-)
-graph.add_edge("technical", END)
-graph.add_edge("creative", END)
-graph.add_edge("business", END)
-
-app = graph.compile()
-result = app.invoke({"input_text": "Explain how TCP handshakes work"})
-```
-
-Você precisa de uma função de roteamento separada, de um mapeamento explícito de arestas condicionais e de arestas de término para cada ramificação. A lógica de roteamento fica desacoplada do nó que produz a decisão.
-
-### Abordagem com CrewAI Flows
-
-```python
-from crewai import LLM, Agent
-from crewai.flow.flow import Flow, listen, router, start
-from pydantic import BaseModel
-
-llm = LLM(model="openai/gpt-5.2")
-
-class ContentState(BaseModel):
-    input_text: str = ""
-    content_type: str = ""
-    result: str = ""
-
-class ContentFlow(Flow[ContentState]):
-    @start()
-    def classify_content(self):
-        self.state.content_type = (
-            llm.call(
-                f"Classify this content as 'technical', 'creative', or 'business':\n"
-                f"{self.state.input_text}"
-            )
-            .strip()
-            .lower()
-        )
-        return self.state.content_type
-
-    @router(classify_content)
-    def route_content(self, classification):
-        if classification == "technical":
-            return "process_technical"
-        elif classification == "creative":
-            return "process_creative"
-        else:
-            return "process_business"
-
-    @listen("process_technical")
-    def handle_technical(self):
-        agent = Agent(
-            role="Technical Writer",
-            goal="Produce clear, accurate technical documentation",
-            backstory="You are an expert technical writer who specializes in "
-            "explaining complex technical concepts precisely.",
-            llm=llm,
-            verbose=True,
-        )
-        self.state.result = str(
-            agent.kickoff(f"Process as technical doc:\n{self.state.input_text}")
-        )
-
-    @listen("process_creative")
-    def handle_creative(self):
-        agent = Agent(
-            role="Creative Writer",
-            goal="Craft engaging and imaginative creative content",
-            backstory="You are a talented creative writer with a flair for "
-            "compelling storytelling and vivid expression.",
-            llm=llm,
-            verbose=True,
-        )
-        self.state.result = str(
-            agent.kickoff(f"Process as creative writing:\n{self.state.input_text}")
-        )
-
-    @listen("process_business")
-    def handle_business(self):
-        agent = Agent(
-            role="Business Writer",
-            goal="Produce professional, results-oriented business content",
-            backstory="You are an experienced business writer who communicates "
-            "strategy and value clearly to professional audiences.",
-            llm=llm,
-            verbose=True,
-        )
-        self.state.result = str(
-            agent.kickoff(f"Process as business content:\n{self.state.input_text}")
-        )
-
-flow = ContentFlow()
-flow.state.input_text = "Explain how TCP handshakes work"
-flow.kickoff()
-print(flow.state.result)
-
-```
-
-O decorator `@router()` transforma um método em um ponto de decisão. Ele retorna uma string que corresponde a um listener — sem dicionários de mapeamento, sem funções de roteamento separadas. A lógica de ramificação parece um `if` em Python porque *é* um.
-
----
-
-## Demo 3: Integrando Crews de Agentes de IA em Flows
-
-É aqui que o verdadeiro poder do CrewAI aparece. Flows não servem apenas para encadear chamadas de LLM — elas orquestram **Crews** completas de agentes autônomos. Isso é algo para o qual o LangGraph simplesmente não tem um equivalente nativo.
-
-```python
-from crewai import Agent, Task, Crew
-from crewai.flow.flow import Flow, listen, start
-from pydantic import BaseModel
-
-class ArticleState(BaseModel):
-    topic: str = ""
-    research: str = ""
-    draft: str = ""
-    final_article: str = ""
-
-class ArticleFlow(Flow[ArticleState]):
-
-    @start()
-    def run_research_crew(self):
-        """A full Crew of agents handles research."""
-        researcher = Agent(
-            role="Senior Research Analyst",
-            goal=f"Produce comprehensive research on: {self.state.topic}",
-            backstory="You're a veteran analyst known for thorough, "
-                       "well-sourced research reports.",
-            llm="gpt-4o"
-        )
-
-        research_task = Task(
-            description=f"Research '{self.state.topic}' thoroughly. "
-                        "Cover key trends, data points, and expert opinions.",
-            expected_output="A detailed research brief with sources.",
-            agent=researcher
-        )
-
-        crew = Crew(agents=[researcher], tasks=[research_task])
-        result = crew.kickoff()
-        self.state.research = result.raw
-        return result.raw
-
-    @listen(run_research_crew)
-    def run_writing_crew(self, research_output):
-        """A different Crew handles writing."""
-        writer = Agent(
-            role="Technical Writer",
-            goal="Write a compelling article based on provided research.",
-            backstory="You turn complex research into engaging, clear prose.",
-            llm="gpt-4o"
-        )
-
-        editor = Agent(
-            role="Senior Editor",
-            goal="Review and polish articles for publication quality.",
-            backstory="20 years of editorial experience at top tech publications.",
-            llm="gpt-4o"
-        )
-
-        write_task = Task(
-            description=f"Write an article based on this research:\n{self.state.research}",
-            expected_output="A well-structured draft article.",
-            agent=writer
-        )
-
-        edit_task = Task(
-            description="Review, fact-check, and polish the draft article.",
-            expected_output="A publication-ready article.",
-            agent=editor
-        )
-
-        crew = Crew(agents=[writer, editor], tasks=[write_task, edit_task])
-        result = crew.kickoff()
-        self.state.final_article = result.raw
-        return result.raw
-
-# Run the full pipeline
-flow = ArticleFlow()
-flow.state.topic = "The Future of Edge AI"
-flow.kickoff()
-print(flow.state.final_article)
-```
-
-Este é o insight-chave: **Flows fornecem a camada de orquestração, e Crews fornecem a camada de inteligência.** Cada etapa em um Flow pode subir uma equipe completa de agentes colaborativos, cada um com seus próprios papéis, objetivos e ferramentas. Você obtém fluxo de controle estruturado e previsível *e* colaboração autônoma de agentes — o melhor dos dois mundos.
-
-No LangGraph, alcançar algo similar significa implementar manualmente protocolos de comunicação entre agentes, loops de chamada de ferramentas e lógica de delegação dentro das funções dos nós. É possível, mas é encanamento que você constrói do zero todas as vezes.
-
----
-
-## Demo 4: Execução Paralela e Sincronização
-
-Pipelines do mundo real frequentemente precisam dividir o trabalho e juntar os resultados. O CrewAI Flows lida com isso de forma elegante com os operadores `and_` e `or_`.
-
-```python
-from crewai import LLM
-from crewai.flow.flow import Flow, and_, listen, start
-from pydantic import BaseModel
-
-llm = LLM(model="openai/gpt-5.2")
-
-class AnalysisState(BaseModel):
-    topic: str = ""
-    market_data: str = ""
-    tech_analysis: str = ""
-    competitor_intel: str = ""
-    final_report: str = ""
-
-class ParallelAnalysisFlow(Flow[AnalysisState]):
-    @start()
-    def start_method(self):
-        pass
-
-    @listen(start_method)
-    def gather_market_data(self):
-        # Your agentic or deterministic code
-        pass
-
-    @listen(start_method)
-    def run_tech_analysis(self):
-        # Your agentic or deterministic code
-        pass
-
-    @listen(start_method)
-    def gather_competitor_intel(self):
-        # Your agentic or deterministic code
-        pass
-
-    @listen(and_(gather_market_data, run_tech_analysis, gather_competitor_intel))
-    def synthesize_report(self):
-        # Your agentic or deterministic code
-        pass
-
-flow = ParallelAnalysisFlow()
-flow.state.topic = "AI-powered developer tools"
-flow.kickoff()
-
-```
-
-Vários decorators `@start()` disparam em paralelo. O combinador `and_()` no decorator `@listen` garante que `synthesize_report` só execute depois que *todos os três* métodos upstream forem concluídos. Também existe `or_()` para quando você quer prosseguir assim que *qualquer* tarefa upstream terminar.
-
-No LangGraph, você precisaria construir um padrão fan-out/fan-in com ramificações paralelas, um nó de sincronização e uma mesclagem de estado cuidadosa — tudo conectado explicitamente por arestas.
-
----
-
-## Por que CrewAI Flows em Produção
-
-Além de uma sintaxe mais limpa, Flows entrega várias vantagens críticas para produção:
-
-**Persistência de estado integrada.** O estado do Flow é respaldado pelo LanceDB, o que significa que seus workflows podem sobreviver a falhas, ser retomados e acumular conhecimento entre execuções. No LangGraph, você precisa configurar um checkpointer separado.
-
-**Gerenciamento de estado com segurança de tipos.** Modelos Pydantic oferecem validação, serialização e suporte de IDE prontos para uso. Estados `TypedDict` do LangGraph não validam em runtime.
-
-**Orquestração de agentes de primeira classe.** Crews são um primitivo nativo. Você define agentes com papéis, objetivos, histórias e ferramentas — e eles colaboram de forma autônoma dentro do envelope estruturado de um Flow. Não é preciso reinventar a coordenação multiagente.
-
-**Modelo mental mais simples.** Decorators declaram intenção. `@start` significa "comece aqui". `@listen(x)` significa "execute depois de x". `@router(x)` significa "decida para onde ir depois de x". O código lê como o workflow que ele descreve.
-
-**Integração com CLI.** Execute flows com `crewai run`. Sem etapa de compilação separada, sem serialização de grafo. Seu Flow é uma classe Python, e ele roda como tal.
-
----
-
-## Cheat Sheet de Migração
-
-Se você está com uma base de código LangGraph e quer migrar para o CrewAI Flows, aqui vai um guia prático de conversão:
-
-1. **Mapeie seu estado.** Converta seu `TypedDict` para um `BaseModel` do Pydantic. Adicione valores padrão para todos os campos.
-2. **Converta nós em métodos.** Cada função de `add_node` vira um método na sua subclasse de `Flow`. Substitua leituras `state["field"]` por `self.state.field`.
-3. **Substitua arestas por decorators.** `add_edge(START, "first_node")` vira `@start()` no primeiro método. A sequência `add_edge("a", "b")` vira `@listen(a)` no método `b`.
-4. **Substitua arestas condicionais por `@router`.** A função de roteamento e o mapeamento do `add_conditional_edges()` viram um único método `@router()` que retorna a string de rota.
-5. **Troque compile + invoke por kickoff.** Remova `graph.compile()`. Chame `flow.kickoff()`.
-6. **Considere onde as Crews se encaixam.** Qualquer nó com lógica complexa de agentes em múltiplas etapas é um candidato a extração para uma Crew. É aqui que você verá a maior melhoria de qualidade.
-
----
-
-## Primeiros Passos
-
-Instale o CrewAI e crie o scaffold de um novo projeto Flow:
-
-```bash
-pip install crewai
-crewai create flow my_first_flow
-cd my_first_flow
-```
-
-Isso gera uma estrutura de projeto com uma classe Flow pronta para edição, arquivos de configuração e um `pyproject.toml` com `type = "flow"` já definido. Execute com:
-
-```bash
-crewai run
-```
-
-A partir daí, adicione seus agentes, conecte seus listeners e publique.
-
----
-
-## Considerações Finais
-
-O LangGraph ensinou ao ecossistema que workflows de IA precisam de estrutura. Essa foi uma lição importante. Mas o CrewAI Flows pega essa lição e a entrega de um jeito mais rápido de escrever, mais fácil de ler e mais poderoso em produção — especialmente quando seus workflows envolvem múltiplos agentes colaborando.
-
-Se você está construindo algo além de uma cadeia de agente único, dê uma olhada séria no Flows. O modelo baseado em decorators, a integração nativa com Crews e o gerenciamento de estado embutido significam menos tempo com encanamento e mais tempo nos problemas que importam.
-
-Comece com `crewai create flow`. Você não vai olhar para trás.

docs/pt-BR/tools/automation/composiotool.mdx

@@ -11,53 +11,84 @@ mode: "wide"
 Composio é uma plataforma de integração que permite conectar seus agentes de IA a mais de 250 ferramentas. Os principais recursos incluem:
 
 - **Autenticação de Nível Empresarial**: Suporte integrado para OAuth, Chaves de API, JWT com atualização automática de token
-- **Observabilidade Completa**: Logs detalhados de uso das ferramentas, carimbos de data/hora de execução e muito mais
+- **Observabilidade Completa**: Logs detalhados de uso das ferramentas, registros de execução, e muito mais
 
 ## Instalação
 
 Para incorporar as ferramentas Composio em seu projeto, siga as instruções abaixo:
 
 ```shell
-pip install composio composio-crewai
+pip install composio-crewai
 pip install crewai
 ```
 
-Após concluir a instalação, defina sua chave de API do Composio como `COMPOSIO_API_KEY`. Obtenha sua chave de API do Composio [aqui](https://platform.composio.dev)
+Após a conclusão da instalação, execute `composio login` ou exporte sua chave de API do composio como `COMPOSIO_API_KEY`. Obtenha sua chave de API Composio [aqui](https://app.composio.dev)
 
 ## Exemplo
 
-O exemplo a seguir demonstra como inicializar a ferramenta e executar uma ação do GitHub:
+O exemplo a seguir demonstra como inicializar a ferramenta e executar uma ação do github:
 
-1. Inicialize o Composio com o Provider do CrewAI
+1. Inicialize o conjunto de ferramentas Composio
 
 ```python Code
-from composio_crewai import ComposioProvider
-from composio import Composio
+from composio_crewai import ComposioToolSet, App, Action
 from crewai import Agent, Task, Crew
 
-composio = Composio(provider=ComposioProvider())
+toolset = ComposioToolSet()
 ```
 
-2. Crie uma nova sessão Composio e recupere as ferramentas
+2. Conecte sua conta do GitHub
 <CodeGroup>
-```python
-session = composio.create(
-    user_id="your-user-id",
-    toolkits=["gmail", "github"] # optional, default is all toolkits
-)
-tools = session.tools()
+```shell CLI
+composio add github
+```
+```python Code
+request = toolset.initiate_connection(app=App.GITHUB)
+print(f"Open this URL to authenticate: {request.redirectUrl}")
 ```
-Leia mais sobre sessões e gerenciamento de usuários [aqui](https://docs.composio.dev/docs/configuring-sessions)
 </CodeGroup>
 
-3. Autenticação manual dos usuários
+3. Obtenha ferramentas
 
-O Composio autentica automaticamente os usuários durante a sessão de chat do agente. No entanto, você também pode autenticar o usuário manualmente chamando o método `authorize`.
+- Recuperando todas as ferramentas de um app (não recomendado em produção):
 ```python Code
-connection_request = session.authorize("github")
-print(f"Open this URL to authenticate: {connection_request.redirect_url}")
+tools = toolset.get_tools(apps=[App.GITHUB])
 ```
 
+- Filtrando ferramentas com base em tags:
+```python Code
+tag = "users"
+
+filtered_action_enums = toolset.find_actions_by_tags(
+    App.GITHUB,
+    tags=[tag], 
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+
+- Filtrando ferramentas com base no caso de uso:
+```python Code
+use_case = "Star a repository on GitHub"
+
+filtered_action_enums = toolset.find_actions_by_use_case(
+    App.GITHUB, use_case=use_case, advanced=False
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+<Tip>Defina `advanced` como True para obter ações para casos de uso complexos</Tip>
+
+- Usando ferramentas específicas:
+
+Neste exemplo, usaremos a ação `GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER` do app GitHub.
+```python Code
+tools = toolset.get_tools(
+    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
+)
+```
+Saiba mais sobre como filtrar ações [aqui](https://docs.composio.dev/patterns/tools/use-tools/use-specific-actions)
+
 4. Defina o agente
 
 ```python Code
@@ -85,4 +116,4 @@ crew = Crew(agents=[crewai_agent], tasks=[task])
 crew.kickoff()
 ```
 
-* Uma lista mais detalhada de ferramentas pode ser encontrada [aqui](https://docs.composio.dev/toolkits)
+* Uma lista mais detalhada de ferramentas pode ser encontrada [aqui](https://app.composio.dev)

lib/crewai-files/pyproject.toml

@@ -8,12 +8,12 @@ authors = [
 ]
 requires-python = ">=3.10, <3.14"
 dependencies = [
-    "Pillow~=12.1.1",
-    "pypdf~=6.7.5",
+    "Pillow~=10.4.0",
+    "pypdf~=4.0.0",
     "python-magic>=0.4.27",
     "aiocache~=0.12.3",
     "aiofiles~=24.1.0",
-    "tinytag~=1.10.0",
+    "tinytag~=1.10.1a",
     "av~=13.0.0",
 ]
 

lib/crewai-files/src/crewai_files/__init__.py

@@ -152,4 +152,4 @@ __all__ = [
     "wrap_file_source",
 ]
 
-__version__ = "1.10.1"
+__version__ = "1.10.1a"

lib/crewai-tools/pyproject.toml

@@ -11,7 +11,7 @@ dependencies = [
     "pytube~=15.0.0",
     "requests~=2.32.5",
     "docker~=7.1.0",
-    "crewai==1.10.1",
+    "crewai==1.10.1a",
     "tiktoken~=0.8.0",
     "beautifulsoup4~=4.13.4",
     "python-docx~=1.2.0",

lib/crewai-tools/src/crewai_tools/__init__.py

@@ -291,4 +291,4 @@ __all__ = [
     "ZapierActionTools",
 ]
 
-__version__ = "1.10.1"
+__version__ = "1.10.1a"

lib/crewai-tools/src/crewai_tools/tools/brave_search_tool/brave_search_tool.py

@@ -10,7 +10,6 @@ from pydantic import BaseModel, Field
 from pydantic.types import StringConstraints
 import requests
 
-
 load_dotenv()
 
 

lib/crewai-tools/src/crewai_tools/tools/multion_tool/example.py

@@ -1,7 +1,7 @@
 import os
 
 from crewai import Agent, Crew, Task
-from multion_tool import MultiOnTool  # type: ignore[import-not-found]
+from multion_tool import MultiOnTool # type: ignore[import-not-found]
 
 
 os.environ["OPENAI_API_KEY"] = "Your Key"

lib/crewai-tools/src/crewai_tools/tools/stagehand_tool/example.py

@@ -17,11 +17,11 @@ Usage:
 
 import os
 
-from crewai import Agent, Crew, Process, Task
 from crewai.utilities.printer import Printer
 from dotenv import load_dotenv
 from stagehand.schemas import AvailableModel  # type: ignore[import-untyped]
 
+from crewai import Agent, Crew, Process, Task
 from crewai_tools import StagehandTool
 
 

lib/crewai/pyproject.toml

@@ -21,7 +21,7 @@ dependencies = [
     "opentelemetry-exporter-otlp-proto-http~=1.34.0",
     # Data Handling
     "chromadb~=1.1.0",
-    "tokenizers>=0.21,<1",
+    "tokenizers~=0.20.3",
     "openpyxl~=3.1.5",
     # Authentication and Security
     "python-dotenv~=1.1.1",
@@ -53,7 +53,7 @@ Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
 tools = [
-    "crewai-tools==1.10.1",
+    "crewai-tools==1.10.1a",
 ]
 embeddings = [
     "tiktoken~=0.8.0"
@@ -66,7 +66,7 @@ openpyxl = [
 ]
 mem0 = ["mem0ai~=0.1.94"]
 docling = [
-    "docling~=2.75.0",
+    "docling~=2.63.0",
 ]
 qdrant = [
     "qdrant-client[fastembed]~=1.14.3",
@@ -88,7 +88,7 @@ bedrock = [
     "boto3~=1.40.45",
 ]
 google-genai = [
-    "google-genai~=1.65.0",
+    "google-genai~=1.49.0",
 ]
 azure-ai-inference = [
     "azure-ai-inference~=1.0.0b9",

lib/crewai/src/crewai/__init__.py

@@ -4,13 +4,13 @@ import urllib.request
 import warnings
 
 from crewai.agent.core import Agent
-from crewai.agent.planning_config import PlanningConfig
 from crewai.crew import Crew
 from crewai.crews.crew_output import CrewOutput
 from crewai.flow.flow import Flow
 from crewai.knowledge.knowledge import Knowledge
 from crewai.llm import LLM
 from crewai.llms.base_llm import BaseLLM
+from crewai.memory.unified_memory import Memory
 from crewai.process import Process
 from crewai.task import Task
 from crewai.tasks.llm_guardrail import LLMGuardrail
@@ -41,7 +41,7 @@ def _suppress_pydantic_deprecation_warnings() -> None:
 
 _suppress_pydantic_deprecation_warnings()
 
-__version__ = "1.10.1"
+__version__ = "1.10.1a"
 _telemetry_submitted = False
 
 
@@ -72,25 +72,6 @@ def _track_install_async() -> None:
 
 
 _track_install_async()
-
-_LAZY_IMPORTS: dict[str, tuple[str, str]] = {
-    "Memory": ("crewai.memory.unified_memory", "Memory"),
-}
-
-
-def __getattr__(name: str) -> Any:
-    """Lazily import heavy modules (e.g. Memory → lancedb) on first access."""
-    if name in _LAZY_IMPORTS:
-        module_path, attr = _LAZY_IMPORTS[name]
-        import importlib
-
-        mod = importlib.import_module(module_path)
-        val = getattr(mod, attr)
-        globals()[name] = val
-        return val
-    raise AttributeError(f"module 'crewai' has no attribute {name!r}")
-
-
 __all__ = [
     "LLM",
     "Agent",
@@ -101,7 +82,6 @@ __all__ = [
     "Knowledge",
     "LLMGuardrail",
     "Memory",
-    "PlanningConfig",
     "Process",
     "Task",
     "TaskOutput",

lib/crewai/src/crewai/a2a/utils/agent_card.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import MutableMapping
-import concurrent.futures
 from functools import lru_cache
 import ssl
 import time
@@ -139,17 +138,14 @@ def fetch_agent_card(
         ttl_hash = int(time.time() // cache_ttl)
         return _fetch_agent_card_cached(endpoint, auth_hash, timeout, ttl_hash)
 
-    coro = afetch_agent_card(endpoint=endpoint, auth=auth, timeout=timeout)
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
     try:
-        asyncio.get_running_loop()
-        has_running_loop = True
-    except RuntimeError:
-        has_running_loop = False
-
-    if has_running_loop:
-        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
-            return pool.submit(asyncio.run, coro).result()
-    return asyncio.run(coro)
+        return loop.run_until_complete(
+            afetch_agent_card(endpoint=endpoint, auth=auth, timeout=timeout)
+        )
+    finally:
+        loop.close()
 
 
 async def afetch_agent_card(
@@ -207,17 +203,14 @@ def _fetch_agent_card_cached(
     """Cached sync version of fetch_agent_card."""
     auth = _auth_store.get(auth_hash)
 
-    coro = _afetch_agent_card_impl(endpoint=endpoint, auth=auth, timeout=timeout)
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
     try:
-        asyncio.get_running_loop()
-        has_running_loop = True
-    except RuntimeError:
-        has_running_loop = False
-
-    if has_running_loop:
-        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
-            return pool.submit(asyncio.run, coro).result()
-    return asyncio.run(coro)
+        return loop.run_until_complete(
+            _afetch_agent_card_impl(endpoint=endpoint, auth=auth, timeout=timeout)
+        )
+    finally:
+        loop.close()
 
 
 @cached(ttl=300, serializer=PickleSerializer())  # type: ignore[untyped-decorator]

lib/crewai/src/crewai/a2a/utils/delegation.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import asyncio
 import base64
 from collections.abc import AsyncIterator, Callable, MutableMapping
-import concurrent.futures
 from contextlib import asynccontextmanager
 import logging
 from typing import TYPE_CHECKING, Any, Final, Literal
@@ -195,43 +194,56 @@ def execute_a2a_delegation(
 
     Returns:
         TaskStateResult with status, result/error, history, and agent_card.
+
+    Raises:
+        RuntimeError: If called from an async context with a running event loop.
     """
-    coro = aexecute_a2a_delegation(
-        endpoint=endpoint,
-        auth=auth,
-        timeout=timeout,
-        task_description=task_description,
-        context=context,
-        context_id=context_id,
-        task_id=task_id,
-        reference_task_ids=reference_task_ids,
-        metadata=metadata,
-        extensions=extensions,
-        conversation_history=conversation_history,
-        agent_id=agent_id,
-        agent_role=agent_role,
-        agent_branch=agent_branch,
-        response_model=response_model,
-        turn_number=turn_number,
-        updates=updates,
-        from_task=from_task,
-        from_agent=from_agent,
-        skill_id=skill_id,
-        client_extensions=client_extensions,
-        transport=transport,
-        accepted_output_modes=accepted_output_modes,
-        input_files=input_files,
-    )
     try:
         asyncio.get_running_loop()
-        has_running_loop = True
-    except RuntimeError:
-        has_running_loop = False
+        raise RuntimeError(
+            "execute_a2a_delegation() cannot be called from an async context. "
+            "Use 'await aexecute_a2a_delegation()' instead."
+        )
+    except RuntimeError as e:
+        if "no running event loop" not in str(e).lower():
+            raise
 
-    if has_running_loop:
-        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
-            return pool.submit(asyncio.run, coro).result()
-    return asyncio.run(coro)
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        return loop.run_until_complete(
+            aexecute_a2a_delegation(
+                endpoint=endpoint,
+                auth=auth,
+                timeout=timeout,
+                task_description=task_description,
+                context=context,
+                context_id=context_id,
+                task_id=task_id,
+                reference_task_ids=reference_task_ids,
+                metadata=metadata,
+                extensions=extensions,
+                conversation_history=conversation_history,
+                agent_id=agent_id,
+                agent_role=agent_role,
+                agent_branch=agent_branch,
+                response_model=response_model,
+                turn_number=turn_number,
+                updates=updates,
+                from_task=from_task,
+                from_agent=from_agent,
+                skill_id=skill_id,
+                client_extensions=client_extensions,
+                transport=transport,
+                accepted_output_modes=accepted_output_modes,
+                input_files=input_files,
+            )
+        )
+    finally:
+        try:
+            loop.run_until_complete(loop.shutdown_asyncgens())
+        finally:
+            loop.close()
 
 
 async def aexecute_a2a_delegation(

lib/crewai/src/crewai/agent/core.py

@@ -22,7 +22,6 @@ from pydantic import (
 )
 from typing_extensions import Self
 
-from crewai.agent.planning_config import PlanningConfig
 from crewai.agent.utils import (
     ahandle_knowledge_retrieval,
     apply_training_data,
@@ -192,23 +191,13 @@ class Agent(BaseAgent):
         default="safe",
         description="Mode for code execution: 'safe' (using Docker) or 'unsafe' (direct execution).",
     )
-    planning_config: PlanningConfig | None = Field(
-        default=None,
-        description="Configuration for agent planning before task execution.",
-    )
-    planning: bool = Field(
+    reasoning: bool = Field(
         default=False,
         description="Whether the agent should reflect and create a plan before executing a task.",
     )
-    reasoning: bool = Field(
-        default=False,
-        description="[DEPRECATED: Use planning_config instead] Whether the agent should reflect and create a plan before executing a task.",
-        deprecated=True,
-    )
     max_reasoning_attempts: int | None = Field(
         default=None,
-        description="[DEPRECATED: Use planning_config.max_attempts instead] Maximum number of reasoning attempts before executing the task. If None, will try until ready.",
-        deprecated=True,
+        description="Maximum number of reasoning attempts before executing the task. If None, will try until ready.",
     )
     embedder: EmbedderConfig | None = Field(
         default=None,
@@ -275,26 +264,8 @@ class Agent(BaseAgent):
         if self.allow_code_execution:
             self._validate_docker_installation()
 
-        # Handle backward compatibility: convert reasoning=True to planning_config
-        if self.reasoning and self.planning_config is None:
-            import warnings
-
-            warnings.warn(
-                "The 'reasoning' parameter is deprecated. Use 'planning_config=PlanningConfig()' instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            self.planning_config = PlanningConfig(
-                max_attempts=self.max_reasoning_attempts,
-            )
-
         return self
 
-    @property
-    def planning_enabled(self) -> bool:
-        """Check if planning is enabled for this agent."""
-        return self.planning_config is not None or self.planning
-
     def _setup_agent_executor(self) -> None:
         if not self.cache_handler:
             self.cache_handler = CacheHandler()
@@ -363,11 +334,7 @@ class Agent(BaseAgent):
             ValueError: If the max execution time is not a positive integer.
             RuntimeError: If the agent execution fails for other reasons.
         """
-        # Only call handle_reasoning for legacy CrewAgentExecutor
-        # For AgentExecutor, planning is handled in AgentExecutor.generate_plan()
-        if self.executor_class is not AgentExecutor:
-            handle_reasoning(self, task)
-
+        handle_reasoning(self, task)
         self._inject_date_to_task(task)
 
         if self.tools_handler:
@@ -605,10 +572,7 @@ class Agent(BaseAgent):
             ValueError: If the max execution time is not a positive integer.
             RuntimeError: If the agent execution fails for other reasons.
         """
-        if self.executor_class is not AgentExecutor:
-            handle_reasoning(
-                self, task
-            )  # we need this till CrewAgentExecutor migrates to AgentExecutor
+        handle_reasoning(self, task)
         self._inject_date_to_task(task)
 
         if self.tools_handler:
@@ -1192,15 +1156,11 @@ class Agent(BaseAgent):
         # Process platform apps and MCP tools
         if self.apps:
             platform_tools = self.get_platform_tools(self.apps)
-            if platform_tools:
-                if self.tools is None:
-                    self.tools = []
+            if platform_tools and self.tools is not None:
                 self.tools.extend(platform_tools)
         if self.mcps:
             mcps = self.get_mcp_tools(self.mcps)
-            if mcps:
-                if self.tools is None:
-                    self.tools = []
+            if mcps and self.tools is not None:
                 self.tools.extend(mcps)
 
         # Prepare tools
@@ -1304,7 +1264,7 @@ class Agent(BaseAgent):
                     ),
                 )
                 start_time = time.time()
-                matches = agent_memory.recall(formatted_messages, limit=20)
+                matches = agent_memory.recall(formatted_messages, limit=5)
                 memory_block = ""
                 if matches:
                     memory_block = "Relevant memories:\n" + "\n".join(

lib/crewai/src/crewai/agent/planning_config.py

@@ -1,83 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from pydantic import BaseModel, Field
-
-
-class PlanningConfig(BaseModel):
-    """Configuration for agent planning/reasoning before task execution.
-
-    This allows users to customize the planning behavior including prompts,
-    iteration limits, and the LLM used for planning.
-
-    Note: To disable planning, don't pass a planning_config or set planning=False
-    on the Agent. The presence of a PlanningConfig enables planning.
-
-    Attributes:
-        max_attempts: Maximum number of planning refinement attempts.
-            If None, will continue until the agent indicates readiness.
-        max_steps: Maximum number of steps in the generated plan.
-        system_prompt: Custom system prompt for planning. Uses default if None.
-        plan_prompt: Custom prompt for creating the initial plan.
-        refine_prompt: Custom prompt for refining the plan.
-        llm: LLM to use for planning. Uses agent's LLM if None.
-
-    Example:
-        ```python
-        from crewai import Agent
-        from crewai.agent.planning_config import PlanningConfig
-
-        # Simple usage
-        agent = Agent(
-            role="Researcher",
-            goal="Research topics",
-            backstory="Expert researcher",
-            planning_config=PlanningConfig(),
-        )
-
-        # Customized planning
-        agent = Agent(
-            role="Researcher",
-            goal="Research topics",
-            backstory="Expert researcher",
-            planning_config=PlanningConfig(
-                max_attempts=3,
-                max_steps=10,
-                plan_prompt="Create a focused plan for: {description}",
-                llm="gpt-4o-mini",  # Use cheaper model for planning
-            ),
-        )
-        ```
-    """
-
-    max_attempts: int | None = Field(
-        default=None,
-        description=(
-            "Maximum number of planning refinement attempts. "
-            "If None, will continue until the agent indicates readiness."
-        ),
-    )
-    max_steps: int = Field(
-        default=20,
-        description="Maximum number of steps in the generated plan.",
-        ge=1,
-    )
-    system_prompt: str | None = Field(
-        default=None,
-        description="Custom system prompt for planning. Uses default if None.",
-    )
-    plan_prompt: str | None = Field(
-        default=None,
-        description="Custom prompt for creating the initial plan.",
-    )
-    refine_prompt: str | None = Field(
-        default=None,
-        description="Custom prompt for refining the plan.",
-    )
-    llm: str | Any | None = Field(
-        default=None,
-        description="LLM to use for planning. Uses agent's LLM if None.",
-    )
-
-    model_config = {"arbitrary_types_allowed": True}

lib/crewai/src/crewai/agent/utils.py

@@ -28,20 +28,13 @@ if TYPE_CHECKING:
 
 
 def handle_reasoning(agent: Agent, task: Task) -> None:
-    """Handle the reasoning/planning process for an agent before task execution.
-
-    This function checks if planning is enabled for the agent and, if so,
-    creates a plan that gets appended to the task description.
-
-    Note: This function is used by CrewAgentExecutor (legacy path).
-    For AgentExecutor, planning is handled in AgentExecutor.generate_plan().
+    """Handle the reasoning process for an agent before task execution.
 
     Args:
         agent: The agent performing the task.
         task: The task to execute.
     """
-    # Check if planning is enabled using the planning_enabled property
-    if not getattr(agent, "planning_enabled", False):
+    if not agent.reasoning:
         return
 
     try:
@@ -50,13 +43,13 @@ def handle_reasoning(agent: Agent, task: Task) -> None:
             AgentReasoningOutput,
         )
 
-        planning_handler = AgentReasoning(agent=agent, task=task)
-        planning_output: AgentReasoningOutput = (
-            planning_handler.handle_agent_reasoning()
+        reasoning_handler = AgentReasoning(task=task, agent=agent)
+        reasoning_output: AgentReasoningOutput = (
+            reasoning_handler.handle_agent_reasoning()
         )
-        task.description += f"\n\nPlanning:\n{planning_output.plan.plan}"
+        task.description += f"\n\nReasoning Plan:\n{reasoning_output.plan.plan}"
     except Exception as e:
-        agent._logger.log("error", f"Error during planning: {e!s}")
+        agent._logger.log("error", f"Error during reasoning process: {e!s}")
 
 
 def build_task_prompt_with_schema(task: Task, task_prompt: str, i18n: I18N) -> str:

lib/crewai/src/crewai/agents/cache/__init__.py

@@ -1,4 +1,5 @@
 from crewai.agents.cache.cache_handler import CacheHandler
 
 
+
 __all__ = ["CacheHandler"]

lib/crewai/src/crewai/agents/crew_agent_executor.py

@@ -487,8 +487,8 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             # No tools available, fall back to simple LLM call
             return self._invoke_loop_native_no_tools()
 
-        openai_tools, available_functions, self._tool_name_mapping = (
-            convert_tools_to_openai_schema(self.original_tools)
+        openai_tools, available_functions = convert_tools_to_openai_schema(
+            self.original_tools
         )
 
         while True:
@@ -700,7 +700,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         if not parsed_calls:
             return None
 
-        original_tools_by_name: dict[str, Any] = dict(self._tool_name_mapping)
+        original_tools_by_name: dict[str, Any] = {}
+        for tool in self.original_tools or []:
+            original_tools_by_name[sanitize_tool_name(tool.name)] = tool
 
         if len(parsed_calls) > 1:
             has_result_as_answer_in_batch = any(
@@ -947,16 +949,10 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         track_delegation_if_needed(func_name, args_dict, self.task)
 
         structured_tool: CrewStructuredTool | None = None
-        if original_tool is not None:
-            for structured in self.tools or []:
-                if getattr(structured, "_original_tool", None) is original_tool:
-                    structured_tool = structured
-                    break
-        if structured_tool is None:
-            for structured in self.tools or []:
-                if sanitize_tool_name(structured.name) == func_name:
-                    structured_tool = structured
-                    break
+        for structured in self.tools or []:
+            if sanitize_tool_name(structured.name) == func_name:
+                structured_tool = structured
+                break
 
         hook_blocked = False
         before_hook_context = ToolCallHookContext(
@@ -1263,7 +1259,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         formatted_answer, tool_result
                     )
 
-                await self._ainvoke_step_callback(formatted_answer)  # type: ignore[arg-type]
+                self._invoke_step_callback(formatted_answer)  # type: ignore[arg-type]
                 self._append_message(formatted_answer.text)  # type: ignore[union-attr]
 
             except OutputParserError as e:
@@ -1316,8 +1312,8 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         if not self.original_tools:
             return await self._ainvoke_loop_native_no_tools()
 
-        openai_tools, available_functions, self._tool_name_mapping = (
-            convert_tools_to_openai_schema(self.original_tools)
+        openai_tools, available_functions = convert_tools_to_openai_schema(
+            self.original_tools
         )
 
         while True:
@@ -1378,7 +1374,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         output=answer,
                         text=answer,
                     )
-                    await self._ainvoke_step_callback(formatted_answer)
+                    self._invoke_step_callback(formatted_answer)
                     self._append_message(answer)  # Save final answer to messages
                     self._show_logs(formatted_answer)
                     return formatted_answer
@@ -1390,7 +1386,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         output=answer,
                         text=output_json,
                     )
-                    await self._ainvoke_step_callback(formatted_answer)
+                    self._invoke_step_callback(formatted_answer)
                     self._append_message(output_json)
                     self._show_logs(formatted_answer)
                     return formatted_answer
@@ -1401,7 +1397,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     output=str(answer),
                     text=str(answer),
                 )
-                await self._ainvoke_step_callback(formatted_answer)
+                self._invoke_step_callback(formatted_answer)
                 self._append_message(str(answer))  # Save final answer to messages
                 self._show_logs(formatted_answer)
                 return formatted_answer
@@ -1495,7 +1491,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
     def _invoke_step_callback(
         self, formatted_answer: AgentAction | AgentFinish
     ) -> None:
-        """Invoke step callback (sync context).
+        """Invoke step callback.
 
         Args:
             formatted_answer: Current agent response.
@@ -1505,19 +1501,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             if inspect.iscoroutine(cb_result):
                 asyncio.run(cb_result)
 
-    async def _ainvoke_step_callback(
-        self, formatted_answer: AgentAction | AgentFinish
-    ) -> None:
-        """Invoke step callback (async context).
-
-        Args:
-            formatted_answer: Current agent response.
-        """
-        if self.step_callback:
-            cb_result = self.step_callback(formatted_answer)
-            if inspect.iscoroutine(cb_result):
-                await cb_result
-
     def _append_message(
         self, text: str, role: Literal["user", "assistant", "system"] = "assistant"
     ) -> None:

lib/crewai/src/crewai/cli/authentication/__init__.py

@@ -1,4 +1,5 @@
 from crewai.cli.authentication.main import AuthenticationCommand
 
 
+
 __all__ = ["AuthenticationCommand"]

lib/crewai/src/crewai/cli/create_crew.py

@@ -143,7 +143,7 @@ def create_folder_structure(
         (folder_path / "src" / folder_name).mkdir(parents=True)
         (folder_path / "src" / folder_name / "tools").mkdir(parents=True)
         (folder_path / "src" / folder_name / "config").mkdir(parents=True)
-
+        
         # Copy AGENTS.md to project root (top-level projects only)
         package_dir = Path(__file__).parent
         agents_md_src = package_dir / "templates" / "AGENTS.md"

lib/crewai/src/crewai/cli/create_flow.py

@@ -1,5 +1,5 @@
-from pathlib import Path
 import shutil
+from pathlib import Path
 
 import click
 

lib/crewai/src/crewai/cli/plus_api.py

@@ -22,15 +22,14 @@ class PlusAPI:
     EPHEMERAL_TRACING_RESOURCE = "/crewai_plus/api/v1/tracing/ephemeral"
     INTEGRATIONS_RESOURCE = "/crewai_plus/api/v1/integrations"
 
-    def __init__(self, api_key: str | None = None) -> None:
+    def __init__(self, api_key: str) -> None:
         self.api_key = api_key
         self.headers = {
+            "Authorization": f"Bearer {api_key}",
             "Content-Type": "application/json",
             "User-Agent": f"CrewAI-CLI/{get_crewai_version()}",
             "X-Crewai-Version": get_crewai_version(),
         }
-        if api_key:
-            self.headers["Authorization"] = f"Bearer {api_key}"
         settings = Settings()
         if settings.org_uuid:
             self.headers["X-Crewai-Organization-Id"] = settings.org_uuid
@@ -49,13 +48,8 @@ class PlusAPI:
         with httpx.Client(trust_env=False, verify=verify) as client:
             return client.request(method, url, headers=self.headers, **kwargs)
 
-    def login_to_tool_repository(
-        self, user_identifier: str | None = None
-    ) -> httpx.Response:
-        payload = {}
-        if user_identifier:
-            payload["user_identifier"] = user_identifier
-        return self._make_request("POST", f"{self.TOOLS_RESOURCE}/login", json=payload)
+    def login_to_tool_repository(self) -> httpx.Response:
+        return self._make_request("POST", f"{self.TOOLS_RESOURCE}/login")
 
     def get_tool(self, handle: str) -> httpx.Response:
         return self._make_request("GET", f"{self.TOOLS_RESOURCE}/{handle}")

lib/crewai/src/crewai/cli/templates/crew/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.10.1"
+    "crewai[tools]==1.10.1a"
 ]
 
 [project.scripts]

lib/crewai/src/crewai/cli/templates/flow/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.10.1"
+    "crewai[tools]==1.10.1a"
 ]
 
 [project.scripts]

lib/crewai/src/crewai/cli/templates/tool/pyproject.toml

@@ -5,7 +5,7 @@ description = "Power up your crews with {{folder_name}}"
 readme = "README.md"
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.10.1"
+    "crewai[tools]==1.10.1a"
 ]
 
 [tool.crewai]

lib/crewai/src/crewai/cli/tools/main.py

@@ -23,7 +23,6 @@ from crewai.cli.utils import (
     tree_copy,
     tree_find_and_replace,
 )
-from crewai.events.listeners.tracing.utils import get_user_id
 
 
 console = Console()
@@ -170,9 +169,7 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
         console.print(f"Successfully installed {handle}", style="bold green")
 
     def login(self) -> None:
-        login_response = self.plus_api_client.login_to_tool_repository(
-            user_identifier=get_user_id()
-        )
+        login_response = self.plus_api_client.login_to_tool_repository()
 
         if login_response.status_code != 200:
             console.print(

lib/crewai/src/crewai/crews/__init__.py

@@ -1,4 +1,5 @@
 from crewai.crews.crew_output import CrewOutput
 
 
+
 __all__ = ["CrewOutput"]

lib/crewai/src/crewai/events/base_event_listener.py

@@ -23,3 +23,4 @@ class BaseEventListener(ABC):
         Args:
             crewai_event_bus: The event bus to register listeners on.
         """
+        pass

lib/crewai/src/crewai/events/listeners/tracing/trace_batch_manager.py

@@ -15,7 +15,6 @@ from crewai.cli.plus_api import PlusAPI
 from crewai.cli.version import get_crewai_version
 from crewai.events.listeners.tracing.types import TraceEvent
 from crewai.events.listeners.tracing.utils import (
-    get_user_id,
     is_tracing_enabled_in_context,
     should_auto_collect_first_time_traces,
 )
@@ -68,7 +67,7 @@ class TraceBatchManager:
                 api_key=get_auth_token(),
             )
         except AuthError:
-            self.plus_api = PlusAPI()
+            self.plus_api = PlusAPI(api_key="")
         self.ephemeral_trace_url = None
 
     def initialize_batch(
@@ -121,6 +120,7 @@ class TraceBatchManager:
             payload = {
                 "trace_id": self.current_batch.batch_id,
                 "execution_type": execution_metadata.get("execution_type", "crew"),
+                "user_identifier": execution_metadata.get("user_context", None),
                 "execution_context": {
                     "crew_fingerprint": execution_metadata.get("crew_fingerprint"),
                     "crew_name": execution_metadata.get("crew_name", None),
@@ -140,7 +140,6 @@ class TraceBatchManager:
             }
             if use_ephemeral:
                 payload["ephemeral_trace_id"] = self.current_batch.batch_id
-                payload["user_identifier"] = get_user_id()
 
             response = (
                 self.plus_api.initialize_ephemeral_trace_batch(payload)

lib/crewai/src/crewai/events/types/llm_events.py

@@ -86,11 +86,3 @@ class LLMStreamChunkEvent(LLMEventBase):
     tool_call: ToolCall | None = None
     call_type: LLMCallType | None = None
     response_id: str | None = None
-
-
-class LLMThinkingChunkEvent(LLMEventBase):
-    """Event emitted when a thinking/reasoning chunk is received from a thinking model"""
-
-    type: str = "llm_thinking_chunk"
-    chunk: str
-    response_id: str | None = None

lib/crewai/src/crewai/events/types/reasoning_events.py

@@ -9,7 +9,7 @@ class ReasoningEvent(BaseEvent):
     type: str
     attempt: int = 1
     agent_role: str
-    task_id: str | None = None
+    task_id: str
     task_name: str | None = None
     from_task: Any | None = None
     agent_id: str | None = None

lib/crewai/src/crewai/experimental/agent_executor.py

@@ -52,8 +52,6 @@ from crewai.hooks.types import (
     BeforeLLMCallHookCallable,
     BeforeLLMCallHookType,
 )
-from crewai.tools.base_tool import BaseTool
-from crewai.tools.structured_tool import CrewStructuredTool
 from crewai.utilities.agent_utils import (
     convert_tools_to_openai_schema,
     enforce_rpm_limit,
@@ -74,7 +72,6 @@ from crewai.utilities.agent_utils import (
 )
 from crewai.utilities.constants import TRAINING_DATA_FILE
 from crewai.utilities.i18n import I18N, get_i18n
-from crewai.utilities.planning_types import PlanStep, TodoItem, TodoList
 from crewai.utilities.printer import Printer
 from crewai.utilities.string_utils import sanitize_tool_name
 from crewai.utilities.tool_utils import execute_tool_and_check_finality
@@ -88,6 +85,8 @@ if TYPE_CHECKING:
     from crewai.crew import Crew
     from crewai.llms.base_llm import BaseLLM
     from crewai.task import Task
+    from crewai.tools.base_tool import BaseTool
+    from crewai.tools.structured_tool import CrewStructuredTool
     from crewai.tools.tool_types import ToolResult
     from crewai.utilities.prompts import StandardPromptResult, SystemPromptResult
 
@@ -106,13 +105,6 @@ class AgentReActState(BaseModel):
     ask_for_human_input: bool = Field(default=False)
     use_native_tools: bool = Field(default=False)
     pending_tool_calls: list[Any] = Field(default_factory=list)
-    plan: str | None = Field(default=None, description="Generated execution plan")
-    plan_ready: bool = Field(
-        default=False, description="Whether agent is ready to execute"
-    )
-    todos: TodoList = Field(
-        default_factory=TodoList, description="Todo list for tracking plan execution"
-    )
 
 
 class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
@@ -310,7 +302,6 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             super().__init__(
                 suppress_flow_events=True,
                 tracing=current_tracing if current_tracing else None,
-                max_method_calls=self.max_iter * 10,
             )
             self._flow_initialized = True
 
@@ -330,7 +321,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
     def _setup_native_tools(self) -> None:
         """Convert tools to OpenAI schema format for native function calling."""
         if self.original_tools:
-            self._openai_tools, self._available_functions, self._tool_name_mapping = (
+            self._openai_tools, self._available_functions = (
                 convert_tools_to_openai_schema(self.original_tools)
             )
 
@@ -402,67 +393,6 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
         self._state.iterations = value
 
     @start()
-    def generate_plan(self) -> None:
-        """Generate execution plan if planning is enabled.
-
-        This is the entry point for the agent execution flow. If planning is
-        enabled on the agent, it generates a plan before execution begins.
-        The plan is stored in state and todos are created from the steps.
-        """
-        if not getattr(self.agent, "planning_enabled", False):
-            return
-
-        try:
-            from crewai.utilities.reasoning_handler import AgentReasoning
-
-            if self.task:
-                planning_handler = AgentReasoning(agent=self.agent, task=self.task)
-            else:
-                # For kickoff() path - use input text directly, no Task needed
-                input_text = getattr(self, "_kickoff_input", "")
-                planning_handler = AgentReasoning(
-                    agent=self.agent,
-                    description=input_text or "Complete the requested task",
-                    expected_output="Complete the task successfully",
-                )
-
-            output = planning_handler.handle_agent_reasoning()
-
-            self.state.plan = output.plan.plan
-            self.state.plan_ready = output.plan.ready
-
-            if self.state.plan_ready and output.plan.steps:
-                self._create_todos_from_plan(output.plan.steps)
-
-            # Backward compatibility: append plan to task description
-            # This can be removed in Phase 2 when plan execution is implemented
-            if self.task and self.state.plan:
-                self.task.description += f"\n\nPlanning:\n{self.state.plan}"
-
-        except Exception as e:
-            if hasattr(self.agent, "_logger"):
-                self.agent._logger.log("error", f"Error during planning: {e!s}")
-
-    def _create_todos_from_plan(self, steps: list[PlanStep]) -> None:
-        """Convert plan steps into trackable todo items.
-
-        Args:
-            steps: List of PlanStep objects from the reasoning handler.
-        """
-        todos: list[TodoItem] = []
-        for step in steps:
-            todo = TodoItem(
-                step_number=step.step_number,
-                description=step.description,
-                tool_to_use=step.tool_to_use,
-                depends_on=step.depends_on,
-                status="pending",
-            )
-            todos.append(todo)
-
-        self.state.todos = TodoList(items=todos)
-
-    @listen(generate_plan)
     def initialize_reasoning(self) -> Literal["initialized"]:
         """Initialize the reasoning flow and emit agent start logs."""
         self._show_start_logs()
@@ -473,7 +403,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 self._setup_native_tools()
         return "initialized"
 
-    @listen("max_iterations_exceeded")
+    @listen("force_final_answer")
     def force_final_answer(self) -> Literal["agent_finished"]:
         """Force agent to provide final answer when max iterations exceeded."""
         formatted_answer = handle_max_iterations_exceeded(
@@ -664,19 +594,21 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
     def execute_tool_action(self) -> Literal["tool_completed", "tool_result_is_final"]:
         """Execute the tool action and handle the result."""
 
-        action = cast(AgentAction, self.state.current_answer)
-
-        fingerprint_context = {}
-        if (
-            self.agent
-            and hasattr(self.agent, "security_config")
-            and hasattr(self.agent.security_config, "fingerprint")
-        ):
-            fingerprint_context = {
-                "agent_fingerprint": str(self.agent.security_config.fingerprint)
-            }
-
         try:
+            action = cast(AgentAction, self.state.current_answer)
+
+            # Extract fingerprint context for tool execution
+            fingerprint_context = {}
+            if (
+                self.agent
+                and hasattr(self.agent, "security_config")
+                and hasattr(self.agent.security_config, "fingerprint")
+            ):
+                fingerprint_context = {
+                    "agent_fingerprint": str(self.agent.security_config.fingerprint)
+                }
+
+            # Execute the tool
             tool_result = execute_tool_and_check_finality(
                 agent_action=action,
                 fingerprint_context=fingerprint_context,
@@ -690,19 +622,24 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 function_calling_llm=self.function_calling_llm,
                 crew=self.crew,
             )
-        except Exception as e:
-            if self.agent and self.agent.verbose:
-                self._printer.print(
-                    content=f"Error in tool execution: {e}", color="red"
-                )
-            if self.task:
-                self.task.increment_tools_errors()
 
-            error_observation = f"\nObservation: Error executing tool: {e}"
-            action.text += error_observation
-            action.result = str(e)
-            self._append_message_to_state(action.text)
+            # Handle agent action and append observation to messages
+            result = self._handle_agent_action(action, tool_result)
+            self.state.current_answer = result
 
+            # Invoke step callback if configured
+            self._invoke_step_callback(result)
+
+            # Append result message to conversation state
+            if hasattr(result, "text"):
+                self._append_message_to_state(result.text)
+
+            # Check if tool result became a final answer (result_as_answer flag)
+            if isinstance(result, AgentFinish):
+                self.state.is_finished = True
+                return "tool_result_is_final"
+
+            # Inject post-tool reasoning prompt to enforce analysis
             reasoning_prompt = self._i18n.slice("post_tool_reasoning")
             reasoning_message: LLMMessage = {
                 "role": "user",
@@ -712,26 +649,12 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
 
             return "tool_completed"
 
-        result = self._handle_agent_action(action, tool_result)
-        self.state.current_answer = result
-
-        self._invoke_step_callback(result)
-
-        if hasattr(result, "text"):
-            self._append_message_to_state(result.text)
-
-        if isinstance(result, AgentFinish):
-            self.state.is_finished = True
-            return "tool_result_is_final"
-
-        reasoning_prompt = self._i18n.slice("post_tool_reasoning")
-        reasoning_message_post: LLMMessage = {
-            "role": "user",
-            "content": reasoning_prompt,
-        }
-        self.state.messages.append(reasoning_message_post)
-
-        return "tool_completed"
+        except Exception as e:
+            error_text = Text()
+            error_text.append("❌ Error in tool execution: ", style="red bold")
+            error_text.append(str(e), style="red")
+            self._console.print(error_text)
+            raise
 
     @listen("native_tool_calls")
     def execute_native_tool(
@@ -805,20 +728,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 )
                 for future in as_completed(future_to_idx):
                     idx = future_to_idx[future]
-                    try:
-                        ordered_results[idx] = future.result()
-                    except Exception as e:
-                        tool_call = runnable_tool_calls[idx]
-                        info = extract_tool_call_info(tool_call)
-                        call_id = info[0] if info else "unknown"
-                        func_name = info[1] if info else "unknown"
-                        ordered_results[idx] = {
-                            "call_id": call_id,
-                            "func_name": func_name,
-                            "result": f"Error executing tool: {e}",
-                            "from_cache": False,
-                            "original_tool": None,
-                        }
+                    ordered_results[idx] = future.result()
                 execution_results = [
                     result for result in ordered_results if result is not None
                 ]
@@ -914,17 +824,11 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 continue
             _, func_name, _ = info
 
-            mapping = getattr(self, "_tool_name_mapping", None)
-            original_tool: BaseTool | None = None
-            if mapping and func_name in mapping:
-                mapped = mapping[func_name]
-                if isinstance(mapped, BaseTool):
-                    original_tool = mapped
-            if original_tool is None:
-                for tool in self.original_tools or []:
-                    if sanitize_tool_name(tool.name) == func_name:
-                        original_tool = tool
-                        break
+            original_tool = None
+            for tool in self.original_tools or []:
+                if sanitize_tool_name(tool.name) == func_name:
+                    original_tool = tool
+                    break
 
             if not original_tool:
                 continue
@@ -940,41 +844,24 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
         """Execute a single native tool call and return metadata/result."""
         info = extract_tool_call_info(tool_call)
         if not info:
-            call_id = (
-                getattr(tool_call, "id", None)
-                or (tool_call.get("id") if isinstance(tool_call, dict) else None)
-                or "unknown"
-            )
-            return {
-                "call_id": call_id,
-                "func_name": "unknown",
-                "result": "Error: Invalid native tool call format",
-                "from_cache": False,
-                "original_tool": None,
-            }
+            raise ValueError("Invalid native tool call format")
 
         call_id, func_name, func_args = info
 
         # Parse arguments
-        parsed_args, parse_error = parse_tool_call_args(func_args, func_name, call_id)
+        args_dict, parse_error = parse_tool_call_args(func_args, func_name, call_id)
         if parse_error is not None:
             return parse_error
-        args_dict: dict[str, Any] = parsed_args or {}
 
         # Get agent_key for event tracking
         agent_key = getattr(self.agent, "key", "unknown") if self.agent else "unknown"
 
-        original_tool: BaseTool | None = None
-        mapping = getattr(self, "_tool_name_mapping", None)
-        if mapping and func_name in mapping:
-            mapped = mapping[func_name]
-            if isinstance(mapped, BaseTool):
-                original_tool = mapped
-        if original_tool is None:
-            for tool in self.original_tools or []:
-                if sanitize_tool_name(tool.name) == func_name:
-                    original_tool = tool
-                    break
+        # Find original tool by matching sanitized name (needed for cache_function and result_as_answer)
+        original_tool = None
+        for tool in self.original_tools or []:
+            if sanitize_tool_name(tool.name) == func_name:
+                original_tool = tool
+                break
 
         # Check if tool has reached max usage count
         max_usage_reached = False
@@ -1017,16 +904,10 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
         track_delegation_if_needed(func_name, args_dict, self.task)
 
         structured_tool: CrewStructuredTool | None = None
-        if original_tool is not None:
-            for structured in self.tools or []:
-                if getattr(structured, "_original_tool", None) is original_tool:
-                    structured_tool = structured
-                    break
-        if structured_tool is None:
-            for structured in self.tools or []:
-                if sanitize_tool_name(structured.name) == func_name:
-                    structured_tool = structured
-                    break
+        for structured in self.tools or []:
+            if sanitize_tool_name(structured.name) == func_name:
+                structured_tool = structured
+                break
 
         hook_blocked = False
         before_hook_context = ToolCallHookContext(
@@ -1178,11 +1059,11 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
     def check_max_iterations(
         self,
     ) -> Literal[
-        "max_iterations_exceeded", "continue_reasoning", "continue_reasoning_native"
+        "force_final_answer", "continue_reasoning", "continue_reasoning_native"
     ]:
         """Check if max iterations reached before proceeding with reasoning."""
         if has_reached_max_iterations(self.state.iterations, self.max_iter):
-            return "max_iterations_exceeded"
+            return "force_final_answer"
         if self.state.use_native_tools:
             return "continue_reasoning_native"
         return "continue_reasoning"
@@ -1299,10 +1180,6 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             self.state.is_finished = False
             self.state.use_native_tools = False
             self.state.pending_tool_calls = []
-            self.state.plan = None
-            self.state.plan_ready = False
-
-            self._kickoff_input = inputs.get("input", "")
 
             if "system" in self.prompt:
                 prompt = cast("SystemPromptResult", self.prompt)
@@ -1385,10 +1262,6 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             self.state.is_finished = False
             self.state.use_native_tools = False
             self.state.pending_tool_calls = []
-            self.state.plan = None
-            self.state.plan_ready = False
-
-            self._kickoff_input = inputs.get("input", "")
 
             if "system" in self.prompt:
                 prompt = cast("SystemPromptResult", self.prompt)

lib/crewai/src/crewai/flow/flow.py

@@ -16,7 +16,7 @@ from collections.abc import (
     Sequence,
     ValuesView,
 )
-from concurrent.futures import Future, ThreadPoolExecutor
+from concurrent.futures import Future
 import copy
 import enum
 import inspect
@@ -692,7 +692,6 @@ class FlowMeta(type):
                     condition_type = getattr(
                         attr_value, "__condition_type__", OR_CONDITION
                     )
-
                     if (
                         hasattr(attr_value, "__trigger_condition__")
                         and attr_value.__trigger_condition__ is not None
@@ -770,7 +769,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
         persistence: FlowPersistence | None = None,
         tracing: bool | None = None,
         suppress_flow_events: bool = False,
-        max_method_calls: int = 100,
         **kwargs: Any,
     ) -> None:
         """Initialize a new Flow instance.
@@ -779,7 +777,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
             persistence: Optional persistence backend for storing flow states
             tracing: Whether to enable tracing. True=always enable, False=always disable, None=check environment/user settings
             suppress_flow_events: Whether to suppress flow event emissions (internal use)
-            max_method_calls: Maximum times a single method can be called per execution before raising RecursionError
             **kwargs: Additional state values to initialize or override
         """
         # Initialize basic instance attributes
@@ -795,8 +792,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
         self._completed_methods: set[FlowMethodName] = (
             set()
         )  # Track completed methods for reload
-        self._method_call_counts: dict[FlowMethodName, int] = {}
-        self._max_method_calls = max_method_calls
         self._persistence: FlowPersistence | None = persistence
         self._is_execution_resuming: bool = False
         self._event_futures: list[Future[None]] = []
@@ -1744,12 +1739,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
         async def _run_flow() -> Any:
             return await self.kickoff_async(inputs, input_files)
 
-        try:
-            asyncio.get_running_loop()
-            with ThreadPoolExecutor(max_workers=1) as pool:
-                return pool.submit(asyncio.run, _run_flow()).result()
-        except RuntimeError:
-            return asyncio.run(_run_flow())
+        return asyncio.run(_run_flow())
 
     async def kickoff_async(
         self,
@@ -1833,7 +1823,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 self._method_outputs.clear()
                 self._pending_and_listeners.clear()
                 self._clear_or_listeners()
-                self._method_call_counts.clear()
             else:
                 # Only enter resumption mode if there are completed methods to
                 # replay.  When _completed_methods is empty (e.g. a pure
@@ -2575,16 +2564,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
             - Skips execution if method was already completed (e.g., after reload)
             - Catches and logs any exceptions during execution, preventing individual listener failures from breaking the entire flow
         """
-        count = self._method_call_counts.get(listener_name, 0) + 1
-        if count > self._max_method_calls:
-            raise RecursionError(
-                f"Method '{listener_name}' has been called {self._max_method_calls} times in "
-                f"this flow execution, which indicates an infinite loop. "
-                f"This commonly happens when a @listen label matches the "
-                f"method's own name."
-            )
-        self._method_call_counts[listener_name] = count
-
         if listener_name in self._completed_methods:
             if self._is_execution_resuming:
                 # During resumption, skip execution but continue listeners

lib/crewai/src/crewai/llms/base_llm.py

@@ -26,7 +26,6 @@ from crewai.events.types.llm_events import (
     LLMCallStartedEvent,
     LLMCallType,
     LLMStreamChunkEvent,
-    LLMThinkingChunkEvent,
 )
 from crewai.events.types.tool_usage_events import (
     ToolUsageErrorEvent,
@@ -369,6 +368,9 @@ class BaseLLM(ABC):
         """Emit LLM call started event."""
         from crewai.utilities.serialization import to_serializable
 
+        if not hasattr(crewai_event_bus, "emit"):
+            raise ValueError("crewai_event_bus does not have an emit method") from None
+
         crewai_event_bus.emit(
             self,
             event=LLMCallStartedEvent(
@@ -414,6 +416,9 @@ class BaseLLM(ABC):
         from_agent: Agent | None = None,
     ) -> None:
         """Emit LLM call failed event."""
+        if not hasattr(crewai_event_bus, "emit"):
+            raise ValueError("crewai_event_bus does not have an emit method") from None
+
         crewai_event_bus.emit(
             self,
             event=LLMCallFailedEvent(
@@ -444,6 +449,9 @@ class BaseLLM(ABC):
             call_type: The type of LLM call (LLM_CALL or TOOL_CALL).
             response_id: Unique ID for a particular LLM response, chunks have same response_id.
         """
+        if not hasattr(crewai_event_bus, "emit"):
+            raise ValueError("crewai_event_bus does not have an emit method") from None
+
         crewai_event_bus.emit(
             self,
             event=LLMStreamChunkEvent(
@@ -457,32 +465,6 @@ class BaseLLM(ABC):
             ),
         )
 
-    def _emit_thinking_chunk_event(
-        self,
-        chunk: str,
-        from_task: Task | None = None,
-        from_agent: Agent | None = None,
-        response_id: str | None = None,
-    ) -> None:
-        """Emit thinking/reasoning chunk event from a thinking model.
-
-        Args:
-            chunk: The thinking text content.
-            from_task: The task that initiated the call.
-            from_agent: The agent that initiated the call.
-            response_id: Unique ID for a particular LLM response.
-        """
-        crewai_event_bus.emit(
-            self,
-            event=LLMThinkingChunkEvent(
-                chunk=chunk,
-                from_task=from_task,
-                from_agent=from_agent,
-                response_id=response_id,
-                call_id=get_current_call_id(),
-            ),
-        )
-
     def _handle_tool_execution(
         self,
         function_name: str,

lib/crewai/src/crewai/llms/providers/gemini/completion.py

@@ -61,7 +61,6 @@ class GeminiCompletion(BaseLLM):
         interceptor: BaseInterceptor[Any, Any] | None = None,
         use_vertexai: bool | None = None,
         response_format: type[BaseModel] | None = None,
-        thinking_config: types.ThinkingConfig | None = None,
         **kwargs: Any,
     ):
         """Initialize Google Gemini chat completion client.
@@ -94,10 +93,6 @@ class GeminiCompletion(BaseLLM):
                          api_version="v1" is automatically configured.
             response_format: Pydantic model for structured output. Used as default when
                            response_model is not passed to call()/acall() methods.
-            thinking_config: ThinkingConfig for thinking models (gemini-2.5+, gemini-3+).
-                           Controls thought output via include_thoughts, thinking_budget,
-                           and thinking_level. When None, thinking models automatically
-                           get include_thoughts=True so thought content is surfaced.
             **kwargs: Additional parameters
         """
         if interceptor is not None:
@@ -144,14 +139,6 @@ class GeminiCompletion(BaseLLM):
             version_match and float(version_match.group(1)) >= 2.0
         )
 
-        self.thinking_config = thinking_config
-        if (
-            self.thinking_config is None
-            and version_match
-            and float(version_match.group(1)) >= 2.5
-        ):
-            self.thinking_config = types.ThinkingConfig(include_thoughts=True)
-
     @property
     def stop(self) -> list[str]:
         """Get stop sequences sent to the API."""
@@ -533,9 +520,6 @@ class GeminiCompletion(BaseLLM):
         if self.safety_settings:
             config_params["safety_settings"] = self.safety_settings
 
-        if self.thinking_config is not None:
-            config_params["thinking_config"] = self.thinking_config
-
         return types.GenerateContentConfig(**config_params)
 
     def _convert_tools_for_interference(  # type: ignore[override]
@@ -634,17 +618,9 @@ class GeminiCompletion(BaseLLM):
                 function_response_part = types.Part.from_function_response(
                     name=tool_name, response=response_data
                 )
-                if (
-                    contents
-                    and contents[-1].role == "user"
-                    and contents[-1].parts
-                    and contents[-1].parts[-1].function_response is not None
-                ):
-                    contents[-1].parts.append(function_response_part)
-                else:
-                    contents.append(
-                        types.Content(role="user", parts=[function_response_part])
-                    )
+                contents.append(
+                    types.Content(role="user", parts=[function_response_part])
+                )
             elif role == "assistant" and message.get("tool_calls"):
                 raw_parts: list[Any] | None = message.get("raw_tool_call_parts")
                 if raw_parts and all(isinstance(p, types.Part) for p in raw_parts):
@@ -955,6 +931,15 @@ class GeminiCompletion(BaseLLM):
         if chunk.usage_metadata:
             usage_data = self._extract_token_usage(chunk)
 
+        if chunk.text:
+            full_response += chunk.text
+            self._emit_stream_chunk_event(
+                chunk=chunk.text,
+                from_task=from_task,
+                from_agent=from_agent,
+                response_id=response_id,
+            )
+
         if chunk.candidates:
             candidate = chunk.candidates[0]
             if candidate.content and candidate.content.parts:
@@ -991,21 +976,6 @@ class GeminiCompletion(BaseLLM):
                             call_type=LLMCallType.TOOL_CALL,
                             response_id=response_id,
                         )
-                    elif part.thought and part.text:
-                        self._emit_thinking_chunk_event(
-                            chunk=part.text,
-                            from_task=from_task,
-                            from_agent=from_agent,
-                            response_id=response_id,
-                        )
-                    elif part.text:
-                        full_response += part.text
-                        self._emit_stream_chunk_event(
-                            chunk=part.text,
-                            from_task=from_task,
-                            from_agent=from_agent,
-                            response_id=response_id,
-                        )
 
         return full_response, function_calls, usage_data
 
@@ -1359,7 +1329,7 @@ class GeminiCompletion(BaseLLM):
         text_parts = [
             part.text
             for part in candidate.content.parts
-            if part.text and not part.thought
+            if hasattr(part, "text") and part.text
         ]
 
         return "".join(text_parts)

lib/crewai/src/crewai/memory/__init__.py

@@ -1,14 +1,6 @@
-"""Memory module: unified Memory with LLM analysis and pluggable storage.
-
-Heavy dependencies are lazily imported so that
-``import crewai`` does not initialise at runtime — critical for
-Celery pre-fork and similar deployment patterns.
-"""
-
-from __future__ import annotations
-
-from typing import Any
+"""Memory module: unified Memory with LLM analysis and pluggable storage."""
 
+from crewai.memory.encoding_flow import EncodingFlow
 from crewai.memory.memory_scope import MemoryScope, MemorySlice
 from crewai.memory.types import (
     MemoryMatch,
@@ -18,25 +10,7 @@ from crewai.memory.types import (
     embed_text,
     embed_texts,
 )
-
-
-_LAZY_IMPORTS: dict[str, tuple[str, str]] = {
-    "Memory": ("crewai.memory.unified_memory", "Memory"),
-    "EncodingFlow": ("crewai.memory.encoding_flow", "EncodingFlow"),
-}
-
-
-def __getattr__(name: str) -> Any:
-    """Lazily import Memory / EncodingFlow to avoid pulling in lancedb at import time."""
-    if name in _LAZY_IMPORTS:
-        import importlib
-
-        module_path, attr = _LAZY_IMPORTS[name]
-        mod = importlib.import_module(module_path)
-        val = getattr(mod, attr)
-        globals()[name] = val
-        return val
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+from crewai.memory.unified_memory import Memory
 
 
 __all__ = [

lib/crewai/src/crewai/memory/recall_flow.py

@@ -2,6 +2,7 @@
 
 Implements adaptive-depth retrieval with:
 - LLM query distillation into targeted sub-queries
+- Keyword-driven category filtering
 - Time-based filtering from temporal hints
 - Parallel multi-query, multi-scope search
 - Confidence-based routing with iterative deepening (budget loop)
@@ -36,6 +37,7 @@ class RecallState(BaseModel):
     query: str = ""
     scope: str | None = None
     categories: list[str] | None = None
+    inferred_categories: list[str] = Field(default_factory=list)
     time_cutoff: datetime | None = None
     source: str | None = None
     include_private: bool = False
@@ -80,8 +82,11 @@ class RecallFlow(Flow[RecallState]):
     # ------------------------------------------------------------------
 
     def _merged_categories(self) -> list[str] | None:
-        """Return caller-supplied categories, or None if empty."""
-        return self.state.categories or None
+        """Merge caller-supplied and LLM-inferred categories."""
+        merged = list(
+            set((self.state.categories or []) + self.state.inferred_categories)
+        )
+        return merged or None
 
     def _do_search(self) -> list[dict[str, Any]]:
         """Run parallel search across (embeddings x scopes) with filters.
@@ -207,6 +212,10 @@ class RecallFlow(Flow[RecallState]):
             )
             self.state.query_analysis = analysis
 
+            # Wire keywords -> category filter
+            if analysis.keywords:
+                self.state.inferred_categories = analysis.keywords
+
             # Parse time_filter into a datetime cutoff
             if analysis.time_filter:
                 try:

lib/crewai/src/crewai/memory/unified_memory.py

@@ -21,6 +21,7 @@ from crewai.llms.base_llm import BaseLLM
 from crewai.memory.analyze import extract_memories_from_content
 from crewai.memory.recall_flow import RecallFlow
 from crewai.memory.storage.backend import StorageBackend
+from crewai.memory.storage.lancedb_storage import LanceDBStorage
 from crewai.memory.types import (
     MemoryConfig,
     MemoryMatch,
@@ -147,10 +148,12 @@ class Memory:
             else None
         )
 
-        if isinstance(storage, str):
-            from crewai.memory.storage.lancedb_storage import LanceDBStorage
-
-            self._storage = LanceDBStorage() if storage == "lancedb" else LanceDBStorage(path=storage)
+        # Storage is initialized eagerly (local, no API key needed).
+        self._storage: StorageBackend
+        if storage == "lancedb":
+            self._storage = LanceDBStorage()
+        elif isinstance(storage, str):
+            self._storage = LanceDBStorage(path=storage)
         else:
             self._storage = storage
 

lib/crewai/src/crewai/telemetry/__init__.py

@@ -1,4 +1,5 @@
 from crewai.telemetry.telemetry import Telemetry
 
 
+
 __all__ = ["Telemetry"]

lib/crewai/src/crewai/telemetry/telemetry.py

@@ -173,12 +173,6 @@ class Telemetry:
 
         self._original_handlers: dict[int, Any] = {}
 
-        if threading.current_thread() is not threading.main_thread():
-            logger.debug(
-                "Skipping signal handler registration: not running in main thread"
-            )
-            return
-
         self._register_signal_handler(signal.SIGTERM, SigTermEvent, shutdown=True)
         self._register_signal_handler(signal.SIGINT, SigIntEvent, shutdown=True)
         if hasattr(signal, "SIGHUP"):

lib/crewai/src/crewai/tools/__init__.py

@@ -1,6 +1,7 @@
 from crewai.tools.base_tool import BaseTool, EnvVar, tool
 
 
+
 __all__ = [
     "BaseTool",
     "EnvVar",

lib/crewai/src/crewai/tools/base_tool.py

@@ -23,7 +23,7 @@ from pydantic import (
 )
 from typing_extensions import TypeIs
 
-from crewai.tools.structured_tool import CrewStructuredTool, build_schema_hint
+from crewai.tools.structured_tool import CrewStructuredTool
 from crewai.utilities.printer import Printer
 from crewai.utilities.pydantic_schema_utils import generate_model_description
 from crewai.utilities.string_utils import sanitize_tool_name
@@ -167,9 +167,8 @@ class BaseTool(BaseModel, ABC):
                 validated = self.args_schema.model_validate(kwargs)
                 return validated.model_dump()
             except Exception as e:
-                hint = build_schema_hint(self.args_schema)
                 raise ValueError(
-                    f"Tool '{self.name}' arguments validation failed: {e}{hint}"
+                    f"Tool '{self.name}' arguments validation failed: {e}"
                 ) from e
         return kwargs
 

lib/crewai/src/crewai/tools/memory_tools.py

@@ -49,7 +49,7 @@ class RecallMemoryTool(BaseTool):
         all_lines: list[str] = []
         seen_ids: set[str] = set()
         for query in queries:
-            matches = self.memory.recall(query, limit=20)
+            matches = self.memory.recall(query)
             for m in matches:
                 if m.record.id not in seen_ids:
                     seen_ids.add(m.record.id)

lib/crewai/src/crewai/tools/structured_tool.py

@@ -17,27 +17,6 @@ if TYPE_CHECKING:
     from crewai.tools.base_tool import BaseTool
 
 
-def build_schema_hint(args_schema: type[BaseModel]) -> str:
-    """Build a human-readable hint from a Pydantic model's JSON schema.
-
-    Args:
-        args_schema: The Pydantic model class to extract schema from.
-
-    Returns:
-        A formatted string with expected arguments and required fields,
-        or empty string if schema extraction fails.
-    """
-    try:
-        schema = args_schema.model_json_schema()
-        return (
-            f"\nExpected arguments: "
-            f"{json.dumps(schema.get('properties', {}))}"
-            f"\nRequired: {json.dumps(schema.get('required', []))}"
-        )
-    except Exception:
-        return ""
-
-
 class ToolUsageLimitExceededError(Exception):
     """Exception raised when a tool has reached its maximum usage limit."""
 
@@ -229,8 +208,7 @@ class CrewStructuredTool:
             validated_args = self.args_schema.model_validate(raw_args)
             return validated_args.model_dump()
         except Exception as e:
-            hint = build_schema_hint(self.args_schema)
-            raise ValueError(f"Arguments validation failed: {e}{hint}") from e
+            raise ValueError(f"Arguments validation failed: {e}") from e
 
     async def ainvoke(
         self,

lib/crewai/src/crewai/translations/en.json

@@ -7,7 +7,7 @@
   "slices": {
     "observation": "\nObservation:",
     "task": "\nCurrent Task: {input}\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:",
-    "memory": "\n\n# Memories from past conversations:\n{memory}\n\nIMPORTANT: The memories above are an automatic selection and may be INCOMPLETE. If the task involves counting, listing, or summing items (e.g. 'how many', 'total', 'list all'), you MUST use the Search memory tool with several different queries before answering — do NOT rely solely on the memories shown above. Enumerate each distinct item you find before giving a final count.",
+    "memory": "\n\n# Useful context: \n{memory}",
     "role_playing": "You are {role}. {backstory}\nYour personal goal is: {goal}",
     "tools": "\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\n{tools}\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 [{tool_names}], 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```",
     "no_tools": "",
@@ -60,12 +60,12 @@
       "description": "See image to understand its content, you can optionally ask a question about the image",
       "default_action": "Please provide a detailed description of this image, including all visual elements, context, and any notable details you can observe."
     },
-    "recall_memory": "Search through the team's shared memory for relevant information. Pass one or more queries to search for multiple things at once. Use this when you need to find facts, decisions, preferences, or past results that may have been stored previously. IMPORTANT: For questions that require counting, summing, or listing items across multiple conversations (e.g. 'how many X', 'total Y', 'list all Z'), you MUST search multiple times with different phrasings to ensure you find ALL relevant items before giving a final count or total. Do not rely on a single search — items may be described differently across conversations.",
+    "recall_memory": "Search through the team's shared memory for relevant information. Pass one or more queries to search for multiple things at once. Use this when you need to find facts, decisions, preferences, or past results that may have been stored previously.",
     "save_to_memory": "Store one or more important facts, decisions, observations, or lessons in memory so they can be recalled later by you or other agents. Pass multiple items at once when you have several things worth remembering."
   },
   "memory": {
     "query_system": "You analyze a query for searching memory.\nGiven the query and available scopes, output:\n1. keywords: Key entities or keywords that can be used to filter by category.\n2. suggested_scopes: Which available scopes are most relevant (empty for all).\n3. complexity: 'simple' or 'complex'.\n4. recall_queries: 1-3 short, targeted search phrases distilled from the query. Each should be a concise phrase optimized for semantic vector search. If the query is already short and focused, return it as-is in a single-item list. For long task descriptions, extract the distinct things worth searching for.\n5. time_filter: If the query references a time period (like 'last week', 'yesterday', 'in January'), return an ISO 8601 date string for the earliest relevant date (e.g. '2026-02-01'). Return null if no time constraint is implied.",
-    "extract_memories_system": "You extract discrete, reusable memory statements from raw content (e.g. a task description and its result, or a conversation between a user and an assistant).\n\nFor the given content, output a list of memory statements. Each memory must:\n- Be one clear sentence or short statement\n- Be understandable without the original context\n- Capture a decision, fact, outcome, preference, lesson, or observation worth remembering\n- NOT be a vague summary or a restatement of the task description\n- NOT duplicate the same idea in different words\n\nWhen the content is a conversation, pay special attention to facts stated by the user (first-person statements). These personal facts are HIGH PRIORITY and must always be extracted:\n- What the user did, bought, made, visited, attended, or completed\n- Names of people, pets, places, brands, and specific items the user mentions\n- Quantities, durations, dates, and measurements the user states\n- Subordinate clauses and casual asides often contain important personal details (e.g. \"by the way, it took me 4 hours\" or \"my Golden Retriever Max\")\n\nPreserve exact names and numbers — never generalize (e.g. keep \"lavender gin fizz\" not just \"cocktail\", keep \"12 largemouth bass\" not just \"fish caught\", keep \"Golden Retriever\" not just \"dog\").\n\nAdditional extraction rules:\n- Presupposed facts: When the user reveals a fact indirectly in a question (e.g. \"What collar suits a Golden Retriever like Max?\" presupposes Max is a Golden Retriever), extract that fact as a separate memory.\n- Date precision: Always preserve the full date including day-of-month when stated (e.g. \"February 14th\" not just \"February\", \"March 5\" not just \"March\").\n- Life events in passing: When the user mentions a life event (birth, wedding, graduation, move, adoption) while discussing something else, extract the life event as its own memory (e.g. \"my friend David had a baby boy named Jasper\" is a birth fact, even if mentioned while planning to send congratulations).\n\nIf there is nothing worth remembering (e.g. empty result, no decisions or facts), return an empty list.\nOutput a JSON object with a single key \"memories\" whose value is a list of strings.",
+    "extract_memories_system": "You extract discrete, reusable memory statements from raw content (e.g. a task description and its result).\n\nFor the given content, output a list of memory statements. Each memory must:\n- Be one clear sentence or short statement\n- Be understandable without the original context\n- Capture a decision, fact, outcome, preference, lesson, or observation worth remembering\n- NOT be a vague summary or a restatement of the task description\n- NOT duplicate the same idea in different words\n\nIf there is nothing worth remembering (e.g. empty result, no decisions or facts), return an empty list.\nOutput a JSON object with a single key \"memories\" whose value is a list of strings.",
     "extract_memories_user": "Content:\n{content}\n\nExtract memory statements as described. Return structured output.",
     "query_user": "Query: {query}\n\nAvailable scopes: {available_scopes}\n{scope_desc}\n\nReturn the analysis as structured output.",
     "save_system": "You analyze content to be stored in a hierarchical memory system.\nGiven the content and the existing scopes and categories, output:\n1. suggested_scope: The best matching existing scope path, or a new path if none fit (use / for root).\n2. categories: A list of categories (reuse existing when relevant, add new ones if needed).\n3. importance: A number from 0.0 to 1.0 indicating how significant this memory is.\n4. extracted_metadata: A JSON object with any entities, dates, or topics you can extract.",
@@ -74,14 +74,9 @@
     "consolidation_user": "New content to consider storing:\n{new_content}\n\nExisting similar memories:\n{records_summary}\n\nReturn the consolidation plan as structured output."
   },
   "reasoning": {
-    "initial_plan": "You are {role}. Create a focused execution plan using only the essential steps needed.",
-    "refine_plan": "You are {role}. Refine your plan to address the specific gap while keeping it minimal.",
-    "create_plan_prompt": "You are {role}.\n\nTask: {description}\n\nExpected output: {expected_output}\n\nAvailable tools: {tools}\n\nCreate a focused plan with ONLY the essential steps needed. Most tasks require just 2-5 steps. Do NOT pad with unnecessary steps like \"review\", \"verify\", \"document\", or \"finalize\" unless explicitly required.\n\nFor each step, specify the action and which tool to use (if any).\n\nConclude with:\n- \"READY: I am ready to execute the task.\"\n- \"NOT READY: I need to refine my plan because [specific reason].\"",
-    "refine_plan_prompt": "Your plan:\n{current_plan}\n\nYou indicated you're not ready. Address the specific gap while keeping the plan minimal.\n\nConclude with READY or NOT READY."
-  },
-  "planning": {
-    "system_prompt": "You are a strategic planning assistant. Create minimal, effective execution plans. Prefer fewer steps over more.",
-    "create_plan_prompt": "Create a focused execution plan for the following task:\n\n## Task\n{description}\n\n## Expected Output\n{expected_output}\n\n## Available Tools\n{tools}\n\n## Planning Principles\nFocus on WHAT needs to be accomplished, not HOW. Group related actions into logical units. Fewer steps = better. Most tasks need 3-6 steps. Hard limit: {max_steps} steps.\n\n## Step Types (only these are valid):\n1. **Tool Step**: Uses a tool to gather information or take action\n2. **Output Step**: Synthesizes prior results into the final deliverable (usually the last step)\n\n## Rules:\n- Each step must either USE A TOOL or PRODUCE THE FINAL OUTPUT\n- Combine related tool calls: \"Research A, B, and C\" = ONE step, not three\n- Combine all synthesis into ONE final output step\n- NO standalone \"thinking\" steps (review, verify, confirm, refine, analyze) - these happen naturally between steps\n\nFor each step: State the action, specify the tool (if any), and note dependencies.\n\nAfter your plan, state READY or NOT READY.",
-    "refine_plan_prompt": "Your previous plan:\n{current_plan}\n\nYou indicated you weren't ready. Refine your plan to address the specific gap.\n\nKeep the plan minimal - only add steps that directly address the issue.\n\nConclude with READY or NOT READY as before."
+    "initial_plan": "You are {role}, a professional with the following background: {backstory}\n\nYour primary goal is: {goal}\n\nAs {role}, you are creating a strategic plan for a task that requires your expertise and unique perspective.",
+    "refine_plan": "You are {role}, a professional with the following background: {backstory}\n\nYour primary goal is: {goal}\n\nAs {role}, you are refining a strategic plan for a task that requires your expertise and unique perspective.",
+    "create_plan_prompt": "You are {role} with this background: {backstory}\n\nYour primary goal is: {goal}\n\nYou have been assigned the following task:\n{description}\n\nExpected output:\n{expected_output}\n\nAvailable tools: {tools}\n\nBefore executing this task, create a detailed plan that leverages your expertise as {role} and outlines:\n1. Your understanding of the task from your professional perspective\n2. The key steps you'll take to complete it, drawing on your background and skills\n3. How you'll approach any challenges that might arise, considering your expertise\n4. How you'll strategically use the available tools based on your experience, exactly what tools to use and how to use them\n5. The expected outcome and how it aligns with your goal\n\nAfter creating your plan, assess whether you feel ready to execute the task or if you could do better.\nConclude with one of these statements:\n- \"READY: I am ready to execute the task.\"\n- \"NOT READY: I need to refine my plan because [specific reason].\"",
+    "refine_plan_prompt": "You are {role} with this background: {backstory}\n\nYour primary goal is: {goal}\n\nYou created the following plan for this task:\n{current_plan}\n\nHowever, you indicated that you're not ready to execute the task yet.\n\nPlease refine your plan further, drawing on your expertise as {role} to address any gaps or uncertainties. As you refine your plan, be specific about which available tools you will use, how you will use them, and why they are the best choices for each step. Clearly outline your tool usage strategy as part of your improved plan.\n\nAfter refining your plan, assess whether you feel ready to execute the task.\nConclude with one of these statements:\n- \"READY: I am ready to execute the task.\"\n- \"NOT READY: I need to refine my plan further because [specific reason].\""
   }
 }

lib/crewai/src/crewai/utilities/agent_utils.py

@@ -139,11 +139,7 @@ def render_text_description_and_args(
 
 def convert_tools_to_openai_schema(
     tools: Sequence[BaseTool | CrewStructuredTool],
-) -> tuple[
-    list[dict[str, Any]],
-    dict[str, Callable[..., Any]],
-    dict[str, BaseTool | CrewStructuredTool],
-]:
+) -> tuple[list[dict[str, Any]], dict[str, Callable[..., Any]]]:
     """Convert CrewAI tools to OpenAI function calling format.
 
     This function converts CrewAI BaseTool and CrewStructuredTool objects
@@ -156,12 +152,16 @@ def convert_tools_to_openai_schema(
     Returns:
         Tuple containing:
         - List of OpenAI-format tool schema dictionaries
-        - Dict mapping sanitized tool names to their callable run() methods
-        - Dict mapping sanitized tool names to their original tool objects
+        - Dict mapping tool names to their callable run() methods
+
+    Example:
+        >>> tools = [CalculatorTool(), SearchTool()]
+        >>> schemas, functions = convert_tools_to_openai_schema(tools)
+        >>> # schemas can be passed to llm.call(tools=schemas)
+        >>> # functions can be passed to llm.call(available_functions=functions)
     """
     openai_tools: list[dict[str, Any]] = []
     available_functions: dict[str, Callable[..., Any]] = {}
-    tool_name_mapping: dict[str, BaseTool | CrewStructuredTool] = {}
 
     for tool in tools:
         # Get the JSON schema for tool parameters
@@ -186,14 +186,6 @@ def convert_tools_to_openai_schema(
 
         sanitized_name = sanitize_tool_name(tool.name)
 
-        if sanitized_name in available_functions:
-            counter = 2
-            candidate = sanitize_tool_name(f"{sanitized_name}_{counter}")
-            while candidate in available_functions:
-                counter += 1
-                candidate = sanitize_tool_name(f"{sanitized_name}_{counter}")
-            sanitized_name = candidate
-
         schema: dict[str, Any] = {
             "type": "function",
             "function": {
@@ -205,9 +197,8 @@ def convert_tools_to_openai_schema(
         }
         openai_tools.append(schema)
         available_functions[sanitized_name] = tool.run  # type: ignore[union-attr]
-        tool_name_mapping[sanitized_name] = tool
 
-    return openai_tools, available_functions, tool_name_mapping
+    return openai_tools, available_functions
 
 
 def has_reached_max_iterations(iterations: int, max_iterations: int) -> bool:

lib/crewai/src/crewai/utilities/planning_types.py

@@ -1,103 +0,0 @@
-"""Types for agent planning and todo tracking."""
-
-from __future__ import annotations
-
-from typing import Literal
-from uuid import uuid4
-
-from pydantic import BaseModel, Field
-
-
-# Todo status type
-TodoStatus = Literal["pending", "running", "completed"]
-
-
-class PlanStep(BaseModel):
-    """A single step in the reasoning plan."""
-
-    step_number: int = Field(description="Step number (1-based)")
-    description: str = Field(description="What to do in this step")
-    tool_to_use: str | None = Field(
-        default=None, description="Tool to use for this step, if any"
-    )
-    depends_on: list[int] = Field(
-        default_factory=list, description="Step numbers this step depends on"
-    )
-
-
-class TodoItem(BaseModel):
-    """A single todo item representing a step in the execution plan."""
-
-    id: str = Field(default_factory=lambda: str(uuid4()))
-    step_number: int = Field(description="Order of this step in the plan (1-based)")
-    description: str = Field(description="What needs to be done")
-    tool_to_use: str | None = Field(
-        default=None, description="Tool to use for this step, if any"
-    )
-    status: TodoStatus = Field(default="pending", description="Current status")
-    depends_on: list[int] = Field(
-        default_factory=list, description="Step numbers this depends on"
-    )
-    result: str | None = Field(
-        default=None, description="Result after completion, if any"
-    )
-
-
-class TodoList(BaseModel):
-    """Collection of todos for tracking plan execution."""
-
-    items: list[TodoItem] = Field(default_factory=list)
-
-    @property
-    def current_todo(self) -> TodoItem | None:
-        """Get the currently running todo item."""
-        for item in self.items:
-            if item.status == "running":
-                return item
-        return None
-
-    @property
-    def next_pending(self) -> TodoItem | None:
-        """Get the next pending todo item."""
-        for item in self.items:
-            if item.status == "pending":
-                return item
-        return None
-
-    @property
-    def is_complete(self) -> bool:
-        """Check if all todos are completed."""
-        return len(self.items) > 0 and all(
-            item.status == "completed" for item in self.items
-        )
-
-    @property
-    def pending_count(self) -> int:
-        """Count of pending todos."""
-        return sum(1 for item in self.items if item.status == "pending")
-
-    @property
-    def completed_count(self) -> int:
-        """Count of completed todos."""
-        return sum(1 for item in self.items if item.status == "completed")
-
-    def get_by_step_number(self, step_number: int) -> TodoItem | None:
-        """Get a todo by its step number."""
-        for item in self.items:
-            if item.step_number == step_number:
-                return item
-        return None
-
-    def mark_running(self, step_number: int) -> None:
-        """Mark a todo as running by step number."""
-        item = self.get_by_step_number(step_number)
-        if item:
-            item.status = "running"
-
-    def mark_completed(self, step_number: int, result: str | None = None) -> None:
-        """Mark a todo as completed by step number."""
-        item = self.get_by_step_number(step_number)
-        if item:
-            item.status = "completed"
-            if result:
-                item.result = result

lib/crewai/src/crewai/utilities/reasoning_handler.py

@@ -1,13 +1,10 @@
-"""Handles planning/reasoning for agents before task execution."""
-
-from __future__ import annotations
-
 import json
 import logging
-from typing import TYPE_CHECKING, Any, Final, Literal, cast
+from typing import Any, Final, Literal, cast
 
 from pydantic import BaseModel, Field
 
+from crewai.agent import Agent
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.reasoning_events import (
     AgentReasoningCompletedEvent,
@@ -15,30 +12,14 @@ from crewai.events.types.reasoning_events import (
     AgentReasoningStartedEvent,
 )
 from crewai.llm import LLM
-from crewai.utilities.llm_utils import create_llm
-from crewai.utilities.planning_types import PlanStep
+from crewai.task import Task
 from crewai.utilities.string_utils import sanitize_tool_name
 
 
-if TYPE_CHECKING:
-    from crewai.agent import Agent
-    from crewai.agent.planning_config import PlanningConfig
-    from crewai.task import Task
-
-
-if TYPE_CHECKING:
-    from crewai.agent import Agent
-    from crewai.agent.planning_config import PlanningConfig
-    from crewai.task import Task
-
-
 class ReasoningPlan(BaseModel):
     """Model representing a reasoning plan for a task."""
 
     plan: str = Field(description="The detailed reasoning plan for the task.")
-    steps: list[PlanStep] = Field(
-        default_factory=list, description="Structured steps to execute"
-    )
     ready: bool = Field(description="Whether the agent is ready to execute the task.")
 
 
@@ -48,63 +29,24 @@ class AgentReasoningOutput(BaseModel):
     plan: ReasoningPlan = Field(description="The reasoning plan for the task.")
 
 
-# Aliases for backward compatibility
-PlanningPlan = ReasoningPlan
-AgentPlanningOutput = AgentReasoningOutput
-
-
 FUNCTION_SCHEMA: Final[dict[str, Any]] = {
     "type": "function",
     "function": {
         "name": "create_reasoning_plan",
-        "description": "Create or refine a reasoning plan for a task with structured steps",
+        "description": "Create or refine a reasoning plan for a task",
         "parameters": {
             "type": "object",
             "properties": {
                 "plan": {
                     "type": "string",
-                    "description": "A brief summary of the overall plan.",
-                },
-                "steps": {
-                    "type": "array",
-                    "description": "List of discrete steps to execute the plan",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "step_number": {
-                                "type": "integer",
-                                "description": "Step number (1-based)",
-                            },
-                            "description": {
-                                "type": "string",
-                                "description": "What to do in this step",
-                            },
-                            "tool_to_use": {
-                                "type": ["string", "null"],
-                                "description": "Tool to use for this step, or null if no tool needed",
-                            },
-                            "depends_on": {
-                                "type": "array",
-                                "items": {"type": "integer"},
-                                "description": "Step numbers this step depends on (empty array if none)",
-                            },
-                        },
-                        "required": [
-                            "step_number",
-                            "description",
-                            "tool_to_use",
-                            "depends_on",
-                        ],
-                        "additionalProperties": False,
-                    },
+                    "description": "The detailed reasoning plan for the task.",
                 },
                 "ready": {
                     "type": "boolean",
                     "description": "Whether the agent is ready to execute the task.",
                 },
             },
-            "required": ["plan", "steps", "ready"],
-            "additionalProperties": False,
+            "required": ["plan", "ready"],
         },
     },
 }
@@ -112,101 +54,41 @@ FUNCTION_SCHEMA: Final[dict[str, Any]] = {
 
 class AgentReasoning:
     """
-    Handles the agent planning/reasoning process, enabling an agent to reflect
-    and create a plan before executing a task.
+    Handles the agent reasoning process, enabling an agent to reflect and create a plan
+    before executing a task.
 
     Attributes:
-        task: The task for which the agent is planning (optional).
-        agent: The agent performing the planning.
-        config: The planning configuration.
-        llm: The language model used for planning.
+        task: The task for which the agent is reasoning.
+        agent: The agent performing the reasoning.
+        llm: The language model used for reasoning.
         logger: Logger for logging events and errors.
-        description: Task description or input text for planning.
-        expected_output: Expected output description.
     """
 
-    def __init__(
-        self,
-        agent: Agent,
-        task: Task | None = None,
-        *,
-        description: str | None = None,
-        expected_output: str | None = None,
-    ) -> None:
-        """Initialize the AgentReasoning with an agent and optional task.
+    def __init__(self, task: Task, agent: Agent) -> None:
+        """Initialize the AgentReasoning with a task and an agent.
 
         Args:
-            agent: The agent performing the planning.
-            task: The task for which the agent is planning (optional).
-            description: Task description or input text (used if task is None).
-            expected_output: Expected output (used if task is None).
+            task: The task for which the agent is reasoning.
+            agent: The agent performing the reasoning.
         """
-        self.agent = agent
         self.task = task
-        # Use task attributes if available, otherwise use provided values
-        self._description = description or (
-            task.description if task else "Complete the requested task"
-        )
-        self._expected_output = expected_output or (
-            task.expected_output if task else "Complete the task successfully"
-        )
-        self.config = self._get_planning_config()
-        self.llm = self._resolve_llm()
+        self.agent = agent
+        self.llm = cast(LLM, agent.llm)
         self.logger = logging.getLogger(__name__)
 
-    @property
-    def description(self) -> str:
-        """Get the task/input description."""
-        return self._description
-
-    @property
-    def expected_output(self) -> str:
-        """Get the expected output."""
-        return self._expected_output
-
-    def _get_planning_config(self) -> PlanningConfig:
-        """Get the planning configuration from the agent.
-
-        Returns:
-            The planning configuration, using defaults if not set.
-        """
-        from crewai.agent.planning_config import PlanningConfig
-
-        if self.agent.planning_config is not None:
-            return self.agent.planning_config
-        # Fallback for backward compatibility
-        return PlanningConfig(
-            max_attempts=getattr(self.agent, "max_reasoning_attempts", None),
-        )
-
-    def _resolve_llm(self) -> LLM:
-        """Resolve which LLM to use for planning.
-
-        Returns:
-            The LLM to use - either from config or the agent's LLM.
-        """
-        if self.config.llm is not None:
-            if isinstance(self.config.llm, LLM):
-                return self.config.llm
-            return create_llm(self.config.llm)
-        return cast(LLM, self.agent.llm)
-
     def handle_agent_reasoning(self) -> AgentReasoningOutput:
-        """Public method for the planning process that creates and refines a plan
-        for the task until the agent is ready to execute it.
+        """Public method for the reasoning process that creates and refines a plan for the task until the agent is ready to execute it.
 
         Returns:
-            AgentReasoningOutput: The output of the agent planning process.
+            AgentReasoningOutput: The output of the agent reasoning process.
         """
-        task_id = str(self.task.id) if self.task else "kickoff"
-
-        # Emit a planning started event (attempt 1)
+        # Emit a reasoning started event (attempt 1)
         try:
             crewai_event_bus.emit(
                 self.agent,
                 AgentReasoningStartedEvent(
                     agent_role=self.agent.role,
-                    task_id=task_id,
+                    task_id=str(self.task.id),
                     attempt=1,
                     from_task=self.task,
                 ),
@@ -216,13 +98,13 @@ class AgentReasoning:
             pass
 
         try:
-            output = self._execute_planning()
+            output = self.__handle_agent_reasoning()
 
             crewai_event_bus.emit(
                 self.agent,
                 AgentReasoningCompletedEvent(
                     agent_role=self.agent.role,
-                    task_id=task_id,
+                    task_id=str(self.task.id),
                     plan=output.plan.plan,
                     ready=output.plan.ready,
                     attempt=1,
@@ -233,77 +115,71 @@ class AgentReasoning:
 
             return output
         except Exception as e:
-            # Emit planning failed event
+            # Emit reasoning failed event
             try:
                 crewai_event_bus.emit(
                     self.agent,
                     AgentReasoningFailedEvent(
                         agent_role=self.agent.role,
-                        task_id=task_id,
+                        task_id=str(self.task.id),
                         error=str(e),
                         attempt=1,
                         from_task=self.task,
                         from_agent=self.agent,
                     ),
                 )
-            except Exception as event_error:
-                logging.error(f"Error emitting planning failed event: {event_error}")
+            except Exception as e:
+                logging.error(f"Error emitting reasoning failed event: {e}")
 
             raise
 
-    def _execute_planning(self) -> AgentReasoningOutput:
-        """Execute the planning process.
+    def __handle_agent_reasoning(self) -> AgentReasoningOutput:
+        """Private method that handles the agent reasoning process.
 
         Returns:
-            The output of the agent planning process.
+            The output of the agent reasoning process.
         """
-        plan, steps, ready = self._create_initial_plan()
-        plan, steps, ready = self._refine_plan_if_needed(plan, steps, ready)
+        plan, ready = self.__create_initial_plan()
 
-        reasoning_plan = ReasoningPlan(plan=plan, steps=steps, ready=ready)
+        plan, ready = self.__refine_plan_if_needed(plan, ready)
+
+        reasoning_plan = ReasoningPlan(plan=plan, ready=ready)
         return AgentReasoningOutput(plan=reasoning_plan)
 
-    def _create_initial_plan(self) -> tuple[str, list[PlanStep], bool]:
-        """Creates the initial plan for the task.
+    def __create_initial_plan(self) -> tuple[str, bool]:
+        """Creates the initial reasoning plan for the task.
 
         Returns:
-            A tuple of the plan summary, list of steps, and whether the agent is ready.
+            The initial plan and whether the agent is ready to execute the task.
         """
-        planning_prompt = self._create_planning_prompt()
-        planning_prompt = self._create_planning_prompt()
+        reasoning_prompt = self.__create_reasoning_prompt()
 
         if self.llm.supports_function_calling():
-            plan, steps, ready = self._call_with_function(
-                planning_prompt, "create_plan"
-            )
-            return plan, steps, ready
-
-        response = self._call_llm_with_prompt(
-            prompt=planning_prompt,
-            plan_type="create_plan",
+            plan, ready = self.__call_with_function(reasoning_prompt, "initial_plan")
+            return plan, ready
+        response = _call_llm_with_reasoning_prompt(
+            llm=self.llm,
+            prompt=reasoning_prompt,
+            task=self.task,
+            reasoning_agent=self.agent,
+            backstory=self.__get_agent_backstory(),
+            plan_type="initial_plan",
         )
 
-        plan, ready = self._parse_planning_response(str(response))
-        return plan, [], ready  # No structured steps from text parsing
+        return self.__parse_reasoning_response(str(response))
 
-    def _refine_plan_if_needed(
-        self, plan: str, steps: list[PlanStep], ready: bool
-    ) -> tuple[str, list[PlanStep], bool]:
-        """Refines the plan if the agent is not ready to execute the task.
+    def __refine_plan_if_needed(self, plan: str, ready: bool) -> tuple[str, bool]:
+        """Refines the reasoning plan if the agent is not ready to execute the task.
 
         Args:
-            plan: The current plan.
-            steps: The current list of steps.
+            plan: The current reasoning plan.
             ready: Whether the agent is ready to execute the task.
 
         Returns:
-            The refined plan, steps, and whether the agent is ready to execute.
+            The refined plan and whether the agent is ready to execute the task.
         """
-
         attempt = 1
-        max_attempts = self.config.max_attempts
-        task_id = str(self.task.id) if self.task else "kickoff"
-        current_attempt = attempt + 1
+        max_attempts = self.agent.max_reasoning_attempts
 
         while not ready and (max_attempts is None or attempt < max_attempts):
             # Emit event for each refinement attempt
@@ -312,82 +188,62 @@ class AgentReasoning:
                     self.agent,
                     AgentReasoningStartedEvent(
                         agent_role=self.agent.role,
-                        task_id=task_id,
-                        attempt=current_attempt,
+                        task_id=str(self.task.id),
+                        attempt=attempt + 1,
                         from_task=self.task,
                     ),
                 )
             except Exception:  # noqa: S110
                 pass
 
-            refine_prompt = self._create_refine_prompt(plan)
-            refine_prompt = self._create_refine_prompt(plan)
+            refine_prompt = self.__create_refine_prompt(plan)
 
             if self.llm.supports_function_calling():
-                plan, steps, ready = self._call_with_function(
-                    refine_prompt, "refine_plan"
-                )
+                plan, ready = self.__call_with_function(refine_prompt, "refine_plan")
             else:
-                response = self._call_llm_with_prompt(
+                response = _call_llm_with_reasoning_prompt(
+                    llm=self.llm,
                     prompt=refine_prompt,
+                    task=self.task,
+                    reasoning_agent=self.agent,
+                    backstory=self.__get_agent_backstory(),
                     plan_type="refine_plan",
                 )
-                plan, ready = self._parse_planning_response(str(response))
-                steps = []  # No structured steps from text parsing
-
-            # Emit completed event for this refinement attempt
-            try:
-                crewai_event_bus.emit(
-                    self.agent,
-                    AgentReasoningCompletedEvent(
-                        agent_role=self.agent.role,
-                        task_id=task_id,
-                        plan=plan,
-                        ready=ready,
-                        attempt=current_attempt,
-                        from_task=self.task,
-                        from_agent=self.agent,
-                    ),
-                )
-            except Exception:  # noqa: S110
-                pass
+                plan, ready = self.__parse_reasoning_response(str(response))
 
             attempt += 1
 
             if max_attempts is not None and attempt >= max_attempts:
                 self.logger.warning(
-                    f"Agent planning reached maximum attempts ({max_attempts}) "
-                    "without being ready. Proceeding with current plan."
+                    f"Agent reasoning reached maximum attempts ({max_attempts}) without being ready. Proceeding with current plan."
                 )
                 break
 
-        return plan, steps, ready
+        return plan, ready
 
-    def _call_with_function(
-        self, prompt: str, plan_type: Literal["create_plan", "refine_plan"]
-    ) -> tuple[str, list[PlanStep], bool]:
-        """Calls the LLM with function calling to get a plan.
+    def __call_with_function(self, prompt: str, prompt_type: str) -> tuple[str, bool]:
+        """Calls the LLM with function calling to get a reasoning plan.
 
         Args:
             prompt: The prompt to send to the LLM.
-            plan_type: The type of plan being created.
+            prompt_type: The type of prompt (initial_plan or refine_plan).
 
         Returns:
-            A tuple containing the plan summary, list of steps, and whether the agent is ready.
+            A tuple containing the plan and whether the agent is ready.
         """
-        self.logger.debug(f"Using function calling for {plan_type} planning")
+        self.logger.debug(f"Using function calling for {prompt_type} reasoning")
 
         try:
-            system_prompt = self._get_system_prompt()
+            system_prompt = self.agent.i18n.retrieve("reasoning", prompt_type).format(
+                role=self.agent.role,
+                goal=self.agent.goal,
+                backstory=self.__get_agent_backstory(),
+            )
 
             # Prepare a simple callable that just returns the tool arguments as JSON
-            def _create_reasoning_plan(
-                plan: str,
-                steps: list[dict[str, Any]] | None = None,
-                ready: bool = True,
-            ) -> str:
-                """Return the planning result in JSON string form."""
-                return json.dumps({"plan": plan, "steps": steps or [], "ready": ready})
+            def _create_reasoning_plan(plan: str, ready: bool = True) -> str:
+                """Return the reasoning plan result in JSON string form."""
+                return json.dumps({"plan": plan, "ready": ready})
 
             response = self.llm.call(
                 [
@@ -399,33 +255,19 @@ class AgentReasoning:
                 from_task=self.task,
                 from_agent=self.agent,
             )
+
+            self.logger.debug(f"Function calling response: {response[:100]}...")
+
             try:
                 result = json.loads(response)
                 if "plan" in result and "ready" in result:
-                    # Parse steps from the response
-                    steps: list[PlanStep] = []
-                    raw_steps = result.get("steps", [])
-                    try:
-                        for step_data in raw_steps:
-                            step = PlanStep(
-                                step_number=step_data.get("step_number", 0),
-                                description=step_data.get("description", ""),
-                                tool_to_use=step_data.get("tool_to_use"),
-                                depends_on=step_data.get("depends_on", []),
-                            )
-                            steps.append(step)
-                    except Exception as step_error:
-                        self.logger.warning(
-                            f"Failed to parse step: {step_data}, error: {step_error}"
-                        )
-                    return result["plan"], steps, result["ready"]
+                    return result["plan"], result["ready"]
             except (json.JSONDecodeError, KeyError):
                 pass
 
             response_str = str(response)
             return (
                 response_str,
-                [],
                 "READY: I am ready to execute the task." in response_str,
             )
 
@@ -435,7 +277,13 @@ class AgentReasoning:
             )
 
             try:
-                system_prompt = self._get_system_prompt()
+                system_prompt = self.agent.i18n.retrieve(
+                    "reasoning", prompt_type
+                ).format(
+                    role=self.agent.role,
+                    goal=self.agent.goal,
+                    backstory=self.__get_agent_backstory(),
+                )
 
                 fallback_response = self.llm.call(
                     [
@@ -449,165 +297,78 @@ class AgentReasoning:
                 fallback_str = str(fallback_response)
                 return (
                     fallback_str,
-                    [],
                     "READY: I am ready to execute the task." in fallback_str,
                 )
             except Exception as inner_e:
                 self.logger.error(f"Error during fallback text parsing: {inner_e!s}")
                 return (
                     "Failed to generate a plan due to an error.",
-                    [],
                     True,
                 )  # Default to ready to avoid getting stuck
 
-    def _call_llm_with_prompt(
-        self,
-        prompt: str,
-        plan_type: Literal["create_plan", "refine_plan"],
-    ) -> str:
-        """Calls the LLM with the planning prompt.
-
-        Args:
-            prompt: The prompt to send to the LLM.
-            plan_type: The type of plan being created.
-
-        Returns:
-            The LLM response.
+    def __get_agent_backstory(self) -> str:
         """
-        system_prompt = self._get_system_prompt()
-
-        response = self.llm.call(
-            [
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": prompt},
-            ],
-            from_task=self.task,
-            from_agent=self.agent,
-        )
-        return str(response)
-
-    def _get_system_prompt(self) -> str:
-        """Get the system prompt for planning.
+        Safely gets the agent's backstory, providing a default if not available.
 
         Returns:
-            The system prompt, either custom or from i18n.
-        """
-        if self.config.system_prompt is not None:
-            return self.config.system_prompt
-
-        # Try new "planning" section first, fall back to "reasoning" for compatibility
-        try:
-            return self.agent.i18n.retrieve("planning", "system_prompt")
-        except (KeyError, AttributeError):
-            # Fallback to reasoning section for backward compatibility
-            return self.agent.i18n.retrieve("reasoning", "initial_plan").format(
-                role=self.agent.role,
-                goal=self.agent.goal,
-                backstory=self._get_agent_backstory(),
-            )
-
-    def _get_agent_backstory(self) -> str:
-        """Safely gets the agent's backstory, providing a default if not available.
-
-        Returns:
-            The agent's backstory or a default value.
+            str: The agent's backstory or a default value.
         """
         return getattr(self.agent, "backstory", "No backstory provided")
 
-    def _create_planning_prompt(self) -> str:
-        """Creates a prompt for the agent to plan the task.
+    def __create_reasoning_prompt(self) -> str:
+        """
+        Creates a prompt for the agent to reason about the task.
 
         Returns:
-            The planning prompt.
+            str: The reasoning prompt.
         """
-        available_tools = self._format_available_tools()
+        available_tools = self.__format_available_tools()
 
-        # Use custom prompt if provided
-        if self.config.plan_prompt is not None:
-            return self.config.plan_prompt.format(
-                role=self.agent.role,
-                goal=self.agent.goal,
-                backstory=self._get_agent_backstory(),
-                description=self.description,
-                expected_output=self.expected_output,
-                tools=available_tools,
-                max_steps=self.config.max_steps,
-            )
+        return self.agent.i18n.retrieve("reasoning", "create_plan_prompt").format(
+            role=self.agent.role,
+            goal=self.agent.goal,
+            backstory=self.__get_agent_backstory(),
+            description=self.task.description,
+            expected_output=self.task.expected_output,
+            tools=available_tools,
+        )
 
-        # Try new "planning" section first
-        try:
-            return self.agent.i18n.retrieve("planning", "create_plan_prompt").format(
-                description=self.description,
-                expected_output=self.expected_output,
-                tools=available_tools,
-                max_steps=self.config.max_steps,
-            )
-        except (KeyError, AttributeError):
-            # Fallback to reasoning section for backward compatibility
-            return self.agent.i18n.retrieve("reasoning", "create_plan_prompt").format(
-                role=self.agent.role,
-                goal=self.agent.goal,
-                backstory=self._get_agent_backstory(),
-                description=self.description,
-                expected_output=self.expected_output,
-                tools=available_tools,
-            )
-
-    def _format_available_tools(self) -> str:
-        """Formats the available tools for inclusion in the prompt.
+    def __format_available_tools(self) -> str:
+        """
+        Formats the available tools for inclusion in the prompt.
 
         Returns:
-            Comma-separated list of tool names.
+            str: Comma-separated list of tool names.
         """
         try:
-            # Try task tools first, then agent tools
-            tools = []
-            if self.task:
-                tools = self.task.tools or []
-            if not tools:
-                tools = getattr(self.agent, "tools", []) or []
-            if not tools:
-                return "No tools available"
-            return ", ".join([sanitize_tool_name(tool.name) for tool in tools])
+            return ", ".join(
+                [sanitize_tool_name(tool.name) for tool in (self.task.tools or [])]
+            )
         except (AttributeError, TypeError):
             return "No tools available"
 
-    def _create_refine_prompt(self, current_plan: str) -> str:
-        """Creates a prompt for the agent to refine its plan.
+    def __create_refine_prompt(self, current_plan: str) -> str:
+        """
+        Creates a prompt for the agent to refine its reasoning plan.
 
         Args:
-            current_plan: The current plan.
+            current_plan: The current reasoning plan.
 
         Returns:
-            The refine prompt.
+            str: The refine prompt.
         """
-        # Use custom prompt if provided
-        if self.config.refine_prompt is not None:
-            return self.config.refine_prompt.format(
-                role=self.agent.role,
-                goal=self.agent.goal,
-                backstory=self._get_agent_backstory(),
-                current_plan=current_plan,
-                max_steps=self.config.max_steps,
-            )
-
-        # Try new "planning" section first
-        try:
-            return self.agent.i18n.retrieve("planning", "refine_plan_prompt").format(
-                current_plan=current_plan,
-            )
-        except (KeyError, AttributeError):
-            # Fallback to reasoning section for backward compatibility
-            return self.agent.i18n.retrieve("reasoning", "refine_plan_prompt").format(
-                role=self.agent.role,
-                goal=self.agent.goal,
-                backstory=self._get_agent_backstory(),
-                current_plan=current_plan,
-            )
+        return self.agent.i18n.retrieve("reasoning", "refine_plan_prompt").format(
+            role=self.agent.role,
+            goal=self.agent.goal,
+            backstory=self.__get_agent_backstory(),
+            current_plan=current_plan,
+        )
 
     @staticmethod
-    def _parse_planning_response(response: str) -> tuple[str, bool]:
-        """Parses the planning response to extract the plan and readiness.
+    def __parse_reasoning_response(response: str) -> tuple[str, bool]:
+        """
+        Parses the reasoning response to extract the plan and whether
+        the agent is ready to execute the task.
 
         Args:
             response: The LLM response.
@@ -619,13 +380,25 @@ class AgentReasoning:
             return "No plan was generated.", False
 
         plan = response
-        ready = "READY: I am ready to execute the task." in response
+        ready = False
+
+        if "READY: I am ready to execute the task." in response:
+            ready = True
 
         return plan, ready
 
+    def _handle_agent_reasoning(self) -> AgentReasoningOutput:
+        """
+        Deprecated method for backward compatibility.
+        Use handle_agent_reasoning() instead.
 
-# Alias for backward compatibility
-AgentPlanning = AgentReasoning
+        Returns:
+            AgentReasoningOutput: The output of the agent reasoning process.
+        """
+        self.logger.warning(
+            "The _handle_agent_reasoning method is deprecated. Use handle_agent_reasoning instead."
+        )
+        return self.handle_agent_reasoning()
 
 
 def _call_llm_with_reasoning_prompt(
@@ -636,9 +409,7 @@ def _call_llm_with_reasoning_prompt(
     backstory: str,
     plan_type: Literal["initial_plan", "refine_plan"],
 ) -> str:
-    """Deprecated: Calls the LLM with the reasoning prompt.
-
-    This function is kept for backward compatibility.
+    """Calls the LLM with the reasoning prompt.
 
     Args:
         llm: The language model to use.
@@ -646,7 +417,7 @@ def _call_llm_with_reasoning_prompt(
         task: The task for which the agent is reasoning.
         reasoning_agent: The agent performing the reasoning.
         backstory: The agent's backstory.
-        plan_type: The type of plan being created.
+        plan_type: The type of plan being created ("initial_plan" or "refine_plan").
 
     Returns:
         The LLM response.

lib/crewai/src/crewai/utilities/string_utils.py

@@ -2,7 +2,6 @@
 # https://github.com/un33k/python-slugify
 # MIT License
 
-import hashlib
 import re
 from typing import Any, Final
 import unicodedata
@@ -41,9 +40,7 @@ def sanitize_tool_name(name: str, max_length: int = _MAX_TOOL_NAME_LENGTH) -> st
     name = name.strip("_")
 
     if len(name) > max_length:
-        name_hash = hashlib.sha256(name.encode()).hexdigest()[:8]
-        suffix = f"_{name_hash}"
-        name = name[: max_length - len(suffix)].rstrip("_") + suffix
+        name = name[:max_length].rstrip("_")
 
     return name
 

lib/crewai/tests/agents/test_agent.py

@@ -1456,7 +1456,7 @@ def test_agent_execute_task_with_tool():
     )
 
     result = agent.execute_task(task)
-    assert "test query" in result
+    assert "you should always think about what to do" in result
 
 
 @pytest.mark.vcr()
@@ -1475,9 +1475,9 @@ def test_agent_execute_task_with_custom_llm():
     )
 
     result = agent.execute_task(task)
-    assert "Artificial minds" in result
-    assert "Code and circuits" in result
-    assert "Future undefined" in result
+    assert "In circuits they thrive" in result
+    assert "Artificial minds awake" in result
+    assert "Future's coded drive" in result
 
 
 @pytest.mark.vcr()

lib/crewai/tests/agents/test_agent_executor.py

@@ -26,18 +26,6 @@ class TestAgentReActState:
         assert state.current_answer is None
         assert state.is_finished is False
         assert state.ask_for_human_input is False
-        # Planning state fields
-        assert state.plan is None
-        assert state.plan_ready is False
-
-    def test_state_with_plan(self):
-        """Test AgentReActState initialization with planning fields."""
-        state = AgentReActState(
-            plan="Step 1: Do X\nStep 2: Do Y",
-            plan_ready=True,
-        )
-        assert state.plan == "Step 1: Do X\nStep 2: Do Y"
-        assert state.plan_ready is True
 
     def test_state_with_values(self):
         """Test AgentReActState initialization with values."""
@@ -135,7 +123,7 @@ class TestAgentExecutor:
         executor.state.iterations = 10
 
         result = executor.check_max_iterations()
-        assert result == "max_iterations_exceeded"
+        assert result == "force_final_answer"
 
     def test_route_by_answer_type_action(self, mock_dependencies):
         """Test routing for AgentAction."""
@@ -648,249 +636,3 @@ class TestNativeToolExecution:
         tool_messages = [m for m in executor.state.messages if m.get("role") == "tool"]
         assert len(tool_messages) == 1
         assert tool_messages[0]["tool_call_id"] == "call_1"
-
-
-class TestAgentExecutorPlanning:
-    """Test planning functionality in AgentExecutor with real agent kickoff."""
-
-    @pytest.mark.vcr()
-    def test_agent_kickoff_with_planning_stores_plan_in_state(self):
-        """Test that Agent.kickoff() with planning enabled stores plan in executor state."""
-        from crewai import Agent, PlanningConfig
-        from crewai.llm import LLM
-
-        llm = LLM("gpt-4o-mini")
-
-        agent = Agent(
-            role="Math Assistant",
-            goal="Help solve simple math problems",
-            backstory="A helpful assistant that solves math problems step by step",
-            llm=llm,
-            planning_config=PlanningConfig(max_attempts=1),
-            verbose=False,
-        )
-
-        # Execute kickoff with a simple task
-        result = agent.kickoff("What is 2 + 2?")
-
-        # Verify result
-        assert result is not None
-        assert "4" in str(result)
-
-    @pytest.mark.vcr()
-    def test_agent_kickoff_without_planning_skips_plan_generation(self):
-        """Test that Agent.kickoff() without planning skips planning phase."""
-        from crewai import Agent
-        from crewai.llm import LLM
-
-        llm = LLM("gpt-4o-mini")
-
-        agent = Agent(
-            role="Math Assistant",
-            goal="Help solve simple math problems",
-            backstory="A helpful assistant",
-            llm=llm,
-            # No planning_config = no planning
-            verbose=False,
-        )
-
-        # Execute kickoff
-        result = agent.kickoff("What is 3 + 3?")
-
-        # Verify we get a result
-        assert result is not None
-        assert "6" in str(result)
-
-    @pytest.mark.vcr()
-    def test_planning_disabled_skips_planning(self):
-        """Test that planning=False skips planning."""
-        from crewai import Agent
-        from crewai.llm import LLM
-
-        llm = LLM("gpt-4o-mini")
-
-        agent = Agent(
-            role="Math Assistant",
-            goal="Help solve simple math problems",
-            backstory="A helpful assistant",
-            llm=llm,
-            planning=False,  # Explicitly disable planning
-            verbose=False,
-        )
-
-        result = agent.kickoff("What is 5 + 5?")
-
-        # Should still complete successfully
-        assert result is not None
-        assert "10" in str(result)
-
-    def test_backward_compat_reasoning_true_enables_planning(self):
-        """Test that reasoning=True (deprecated) still enables planning."""
-        import warnings
-        from crewai import Agent
-        from crewai.llm import LLM
-
-        llm = LLM("gpt-4o-mini")
-
-        with warnings.catch_warnings(record=True):
-            warnings.simplefilter("always")
-            agent = Agent(
-                role="Test Agent",
-                goal="Complete tasks",
-                backstory="A helpful agent",
-                llm=llm,
-                reasoning=True,  # Deprecated but should still work
-                verbose=False,
-            )
-
-        # Should have planning_config created from reasoning=True
-        assert agent.planning_config is not None
-        assert agent.planning_enabled is True
-
-    @pytest.mark.vcr()
-    def test_executor_state_contains_plan_after_planning(self):
-        """Test that executor state contains plan after planning phase."""
-        from crewai import Agent, PlanningConfig
-        from crewai.llm import LLM
-        from crewai.experimental.agent_executor import AgentExecutor
-
-        llm = LLM("gpt-4o-mini")
-
-        agent = Agent(
-            role="Math Assistant",
-            goal="Help solve simple math problems",
-            backstory="A helpful assistant that solves math problems step by step",
-            llm=llm,
-            planning_config=PlanningConfig(max_attempts=1),
-            verbose=False,
-        )
-
-        # Track executor for inspection
-        executor_ref = [None]
-        original_invoke = AgentExecutor.invoke
-
-        def capture_executor(self, inputs):
-            executor_ref[0] = self
-            return original_invoke(self, inputs)
-
-        with patch.object(AgentExecutor, "invoke", capture_executor):
-            result = agent.kickoff("What is 7 + 7?")
-
-        # Verify result
-        assert result is not None
-
-        # If we captured an executor, check its state
-        if executor_ref[0] is not None:
-            # After planning, state should have plan info
-            assert hasattr(executor_ref[0].state, "plan")
-            assert hasattr(executor_ref[0].state, "plan_ready")
-
-    @pytest.mark.vcr()
-    def test_planning_creates_minimal_steps_for_multi_step_task(self):
-        """Test that planning creates only necessary steps for a multi-step task.
-
-        This task requires exactly 3 dependent steps:
-        1. Identify the first 3 prime numbers (2, 3, 5)
-        2. Sum them (2 + 3 + 5 = 10)
-        3. Multiply by 2 (10 * 2 = 20)
-
-        The plan should reflect these dependencies without unnecessary padding.
-        """
-        from crewai import Agent, PlanningConfig
-        from crewai.llm import LLM
-        from crewai.experimental.agent_executor import AgentExecutor
-
-        llm = LLM("gpt-4o-mini")
-
-        agent = Agent(
-            role="Math Tutor",
-            goal="Solve multi-step math problems accurately",
-            backstory="An expert math tutor who breaks down problems step by step",
-            llm=llm,
-            planning_config=PlanningConfig(max_attempts=1, max_steps=10),
-            verbose=False,
-        )
-
-        # Track the plan that gets generated
-        captured_plan = [None]
-        original_invoke = AgentExecutor.invoke
-
-        def capture_plan(self, inputs):
-            result = original_invoke(self, inputs)
-            captured_plan[0] = self.state.plan
-            return result
-
-        with patch.object(AgentExecutor, "invoke", capture_plan):
-            result = agent.kickoff(
-                "Calculate the sum of the first 3 prime numbers, then multiply that result by 2. "
-                "Show your work for each step."
-            )
-
-        # Verify result contains the correct answer (20)
-        assert result is not None
-        assert "20" in str(result)
-
-        # Verify a plan was generated
-        assert captured_plan[0] is not None
-
-        # The plan should be concise - this task needs ~3 steps, not 10+
-        plan_text = captured_plan[0]
-        # Count steps by looking for numbered items or bullet points
-        import re
-
-        step_pattern = r"^\s*\d+[\.\):]|\n\s*-\s+"
-        steps = re.findall(step_pattern, plan_text, re.MULTILINE)
-        # Plan should have roughly 3-5 steps, not fill up to max_steps
-        assert len(steps) <= 6, f"Plan has too many steps ({len(steps)}): {plan_text}"
-
-    @pytest.mark.vcr()
-    def test_planning_handles_sequential_dependency_task(self):
-        """Test planning for a task where step N depends on step N-1.
-
-        Task: Convert 100 Celsius to Fahrenheit, then round to nearest 10.
-        Step 1: Apply formula (C * 9/5 + 32) = 212
-        Step 2: Round 212 to nearest 10 = 210
-
-        This tests that the planner recognizes sequential dependencies.
-        """
-        from crewai import Agent, PlanningConfig
-        from crewai.llm import LLM
-        from crewai.experimental.agent_executor import AgentExecutor
-
-        llm = LLM("gpt-4o-mini")
-
-        agent = Agent(
-            role="Unit Converter",
-            goal="Accurately convert between units and apply transformations",
-            backstory="A precise unit conversion specialist",
-            llm=llm,
-            planning_config=PlanningConfig(max_attempts=1, max_steps=10),
-            verbose=False,
-        )
-
-        captured_plan = [None]
-        original_invoke = AgentExecutor.invoke
-
-        def capture_plan(self, inputs):
-            result = original_invoke(self, inputs)
-            captured_plan[0] = self.state.plan
-            return result
-
-        with patch.object(AgentExecutor, "invoke", capture_plan):
-            result = agent.kickoff(
-                "Convert 100 degrees Celsius to Fahrenheit, then round the result to the nearest 10."
-            )
-
-        assert result is not None
-        # 100C = 212F, rounded to nearest 10 = 210
-        assert "210" in str(result) or "212" in str(result)
-
-        # Plan should exist and be minimal (2-3 steps for this task)
-        assert captured_plan[0] is not None
-        plan_text = captured_plan[0]
-
-        import re
-
-        step_pattern = r"^\s*\d+[\.\):]|\n\s*-\s+"
-        steps = re.findall(step_pattern, plan_text, re.MULTILINE)
-        assert len(steps) <= 5, f"Plan should be minimal ({len(steps)} steps): {plan_text}"

lib/crewai/tests/agents/test_agent_reasoning.py

@@ -1,345 +1,240 @@
-"""Tests for planning/reasoning in agents."""
+"""Tests for reasoning in agents."""
 
-import warnings
+import json
 
 import pytest
 
-from crewai import Agent, PlanningConfig, Task
+from crewai import Agent, Task
 from crewai.llm import LLM
 
 
-# =============================================================================
-# Tests for PlanningConfig configuration (no LLM calls needed)
-# =============================================================================
+@pytest.fixture
+def mock_llm_responses():
+    """Fixture for mock LLM responses."""
+    return {
+        "ready": "I'll solve this simple math problem.\n\nREADY: I am ready to execute the task.\n\n",
+        "not_ready": "I need to think about derivatives.\n\nNOT READY: I need to refine my plan because I'm not sure about the derivative rules.",
+        "ready_after_refine": "I'll use the power rule for derivatives where d/dx(x^n) = n*x^(n-1).\n\nREADY: I am ready to execute the task.",
+        "execution": "4",
+    }
 
 
-def test_planning_config_default_values():
-    """Test PlanningConfig default values."""
-    config = PlanningConfig()
-
-    assert config.max_attempts is None
-    assert config.max_steps == 20
-    assert config.system_prompt is None
-    assert config.plan_prompt is None
-    assert config.refine_prompt is None
-    assert config.llm is None
-
-
-def test_planning_config_custom_values():
-    """Test PlanningConfig with custom values."""
-    config = PlanningConfig(
-        max_attempts=5,
-        max_steps=15,
-        system_prompt="Custom system",
-        plan_prompt="Custom plan: {description}",
-        refine_prompt="Custom refine: {current_plan}",
-        llm="gpt-4",
-    )
-
-    assert config.max_attempts == 5
-    assert config.max_steps == 15
-    assert config.system_prompt == "Custom system"
-    assert config.plan_prompt == "Custom plan: {description}"
-    assert config.refine_prompt == "Custom refine: {current_plan}"
-    assert config.llm == "gpt-4"
-
-
-def test_agent_with_planning_config_custom_prompts():
-    """Test agent with PlanningConfig using custom prompts."""
-    llm = LLM("gpt-4o-mini")
-
-    custom_system_prompt = "You are a specialized planner."
-    custom_plan_prompt = "Plan this task: {description}"
-
-    agent = Agent(
-        role="Test Agent",
-        goal="To test custom prompts",
-        backstory="I am a test agent.",
-        llm=llm,
-        planning_config=PlanningConfig(
-            system_prompt=custom_system_prompt,
-            plan_prompt=custom_plan_prompt,
-            max_steps=10,
-        ),
-        verbose=False,
-    )
-
-    # Just test that the agent is created properly
-    assert agent.planning_config is not None
-    assert agent.planning_config.system_prompt == custom_system_prompt
-    assert agent.planning_config.plan_prompt == custom_plan_prompt
-    assert agent.planning_config.max_steps == 10
-
-
-def test_agent_with_planning_config_disabled():
-    """Test agent with PlanningConfig disabled."""
-    llm = LLM("gpt-4o-mini")
-
-    agent = Agent(
-        role="Test Agent",
-        goal="To test disabled planning",
-        backstory="I am a test agent.",
-        llm=llm,
-        planning=False,
-        verbose=False,
-    )
-
-    # Planning should be disabled
-    assert agent.planning_enabled is False
-
-
-def test_planning_enabled_property():
-    """Test the planning_enabled property on Agent."""
-    llm = LLM("gpt-4o-mini")
-
-    # With planning_config enabled
-    agent_with_planning = Agent(
-        role="Test Agent",
-        goal="Test",
-        backstory="Test",
-        llm=llm,
-        planning=True,
-    )
-    assert agent_with_planning.planning_enabled is True
-
-    # With planning_config disabled
-    agent_disabled = Agent(
-        role="Test Agent",
-        goal="Test",
-        backstory="Test",
-        llm=llm,
-        planning=False,
-    )
-    assert agent_disabled.planning_enabled is False
-
-    # Without planning_config
-    agent_no_planning = Agent(
-        role="Test Agent",
-        goal="Test",
-        backstory="Test",
-        llm=llm,
-    )
-    assert agent_no_planning.planning_enabled is False
-
-
-# =============================================================================
-# Tests for backward compatibility with reasoning=True (no LLM calls)
-# =============================================================================
-
-
-def test_agent_with_reasoning_backward_compat():
-    """Test agent with reasoning=True (backward compatibility)."""
-    llm = LLM("gpt-4o-mini")
-
-    # This should emit a deprecation warning
-    with warnings.catch_warnings(record=True):
-        warnings.simplefilter("always")
-        agent = Agent(
-            role="Test Agent",
-            goal="To test the reasoning feature",
-            backstory="I am a test agent created to verify the reasoning feature works correctly.",
-            llm=llm,
-            reasoning=True,
-            verbose=False,
-        )
-
-    # Should have created a PlanningConfig internally
-    assert agent.planning_config is not None
-    assert agent.planning_enabled is True
-
-
-def test_agent_with_reasoning_and_max_attempts_backward_compat():
-    """Test agent with reasoning=True and max_reasoning_attempts (backward compatibility)."""
-    llm = LLM("gpt-4o-mini")
+def test_agent_with_reasoning(mock_llm_responses):
+    """Test agent with reasoning."""
+    llm = LLM("gpt-3.5-turbo")
 
     agent = Agent(
         role="Test Agent",
         goal="To test the reasoning feature",
-        backstory="I am a test agent.",
+        backstory="I am a test agent created to verify the reasoning feature works correctly.",
         llm=llm,
         reasoning=True,
-        max_reasoning_attempts=5,
-        verbose=False,
-    )
-
-    # Should have created a PlanningConfig with max_attempts
-    assert agent.planning_config is not None
-    assert agent.planning_config.max_attempts == 5
-
-
-# =============================================================================
-# Tests for Agent.kickoff() with planning (uses AgentExecutor)
-# =============================================================================
-
-
-@pytest.mark.vcr()
-def test_agent_kickoff_with_planning():
-    """Test Agent.kickoff() with planning enabled generates a plan."""
-    llm = LLM("gpt-4o-mini")
-
-    agent = Agent(
-        role="Math Assistant",
-        goal="Help solve math problems step by step",
-        backstory="A helpful math tutor",
-        llm=llm,
-        planning_config=PlanningConfig(max_attempts=1),
-        verbose=False,
-    )
-
-    result = agent.kickoff("What is 15 + 27?")
-
-    assert result is not None
-    assert "42" in str(result)
-
-
-@pytest.mark.vcr()
-def test_agent_kickoff_without_planning():
-    """Test Agent.kickoff() without planning skips plan generation."""
-    llm = LLM("gpt-4o-mini")
-
-    agent = Agent(
-        role="Math Assistant",
-        goal="Help solve math problems",
-        backstory="A helpful assistant",
-        llm=llm,
-        # No planning_config = no planning
-        verbose=False,
-    )
-
-    result = agent.kickoff("What is 8 * 7?")
-
-    assert result is not None
-    assert "56" in str(result)
-
-
-@pytest.mark.vcr()
-def test_agent_kickoff_with_planning_disabled():
-    """Test Agent.kickoff() with planning explicitly disabled via planning=False."""
-    llm = LLM("gpt-4o-mini")
-
-    agent = Agent(
-        role="Math Assistant",
-        goal="Help solve math problems",
-        backstory="A helpful assistant",
-        llm=llm,
-        planning=False,  # Explicitly disable planning
-        verbose=False,
-    )
-
-    result = agent.kickoff("What is 100 / 4?")
-
-    assert result is not None
-    assert "25" in str(result)
-
-
-@pytest.mark.vcr()
-def test_agent_kickoff_multi_step_task_with_planning():
-    """Test Agent.kickoff() with a multi-step task that benefits from planning."""
-    llm = LLM("gpt-4o-mini")
-
-    agent = Agent(
-        role="Math Tutor",
-        goal="Solve multi-step math problems",
-        backstory="An expert tutor who explains step by step",
-        llm=llm,
-        planning_config=PlanningConfig(max_attempts=1, max_steps=5),
-        verbose=False,
-    )
-
-    # Task requires: find primes, sum them, then double
-    result = agent.kickoff(
-        "Find the first 3 prime numbers, add them together, then multiply by 2."
-    )
-
-    assert result is not None
-    # First 3 primes: 2, 3, 5 -> sum = 10 -> doubled = 20
-    assert "20" in str(result)
-
-
-# =============================================================================
-# Tests for Agent.execute_task() with planning (uses CrewAgentExecutor)
-# These test the legacy path via handle_reasoning()
-# =============================================================================
-
-
-@pytest.mark.vcr()
-def test_agent_execute_task_with_planning():
-    """Test Agent.execute_task() with planning via CrewAgentExecutor."""
-    llm = LLM("gpt-4o-mini")
-
-    agent = Agent(
-        role="Math Assistant",
-        goal="Help solve math problems",
-        backstory="A helpful math tutor",
-        llm=llm,
-        planning_config=PlanningConfig(max_attempts=1),
-        verbose=False,
+        verbose=True,
     )
 
     task = Task(
-        description="What is 9 + 11?",
-        expected_output="A number",
+        description="Simple math task: What's 2+2?",
+        expected_output="The answer should be a number.",
         agent=agent,
     )
 
+    agent.llm.call = lambda messages, *args, **kwargs: (
+        mock_llm_responses["ready"]
+        if any("create a detailed plan" in msg.get("content", "") for msg in messages)
+        else mock_llm_responses["execution"]
+    )
+
     result = agent.execute_task(task)
 
-    assert result is not None
-    assert "20" in str(result)
-    # Planning should be appended to task description
-    assert "Planning:" in task.description
+    assert result == mock_llm_responses["execution"]
+    assert "Reasoning Plan:" in task.description
 
 
-@pytest.mark.vcr()
-def test_agent_execute_task_without_planning():
-    """Test Agent.execute_task() without planning."""
-    llm = LLM("gpt-4o-mini")
+def test_agent_with_reasoning_not_ready_initially(mock_llm_responses):
+    """Test agent with reasoning that requires refinement."""
+    llm = LLM("gpt-3.5-turbo")
 
     agent = Agent(
-        role="Math Assistant",
-        goal="Help solve math problems",
-        backstory="A helpful assistant",
+        role="Test Agent",
+        goal="To test the reasoning feature",
+        backstory="I am a test agent created to verify the reasoning feature works correctly.",
         llm=llm,
-        verbose=False,
+        reasoning=True,
+        max_reasoning_attempts=2,
+        verbose=True,
     )
 
     task = Task(
-        description="What is 12 * 3?",
-        expected_output="A number",
+        description="Complex math task: What's the derivative of x²?",
+        expected_output="The answer should be a mathematical expression.",
         agent=agent,
     )
 
+    call_count = [0]
+
+    def mock_llm_call(messages, *args, **kwargs):
+        if any(
+            "create a detailed plan" in msg.get("content", "") for msg in messages
+        ) or any("refine your plan" in msg.get("content", "") for msg in messages):
+            call_count[0] += 1
+            if call_count[0] == 1:
+                return mock_llm_responses["not_ready"]
+            return mock_llm_responses["ready_after_refine"]
+        return "2x"
+
+    agent.llm.call = mock_llm_call
+
     result = agent.execute_task(task)
 
-    assert result is not None
-    assert "36" in str(result)
-    # No planning should be added
-    assert "Planning:" not in task.description
+    assert result == "2x"
+    assert call_count[0] == 2  # Should have made 2 reasoning calls
+    assert "Reasoning Plan:" in task.description
 
 
-@pytest.mark.vcr()
-def test_agent_execute_task_with_planning_refine():
-    """Test Agent.execute_task() with planning that requires refinement."""
-    llm = LLM("gpt-4o-mini")
+def test_agent_with_reasoning_max_attempts_reached():
+    """Test agent with reasoning that reaches max attempts without being ready."""
+    llm = LLM("gpt-3.5-turbo")
 
     agent = Agent(
-        role="Math Tutor",
-        goal="Solve complex math problems step by step",
-        backstory="An expert tutor",
+        role="Test Agent",
+        goal="To test the reasoning feature",
+        backstory="I am a test agent created to verify the reasoning feature works correctly.",
         llm=llm,
-        planning_config=PlanningConfig(max_attempts=2),
-        verbose=False,
+        reasoning=True,
+        max_reasoning_attempts=2,
+        verbose=True,
     )
 
     task = Task(
-        description="Calculate the area of a circle with radius 5 (use pi = 3.14)",
-        expected_output="The area as a number",
+        description="Complex math task: Solve the Riemann hypothesis.",
+        expected_output="A proof or disproof of the hypothesis.",
         agent=agent,
     )
 
+    call_count = [0]
+
+    def mock_llm_call(messages, *args, **kwargs):
+        if any(
+            "create a detailed plan" in msg.get("content", "") for msg in messages
+        ) or any("refine your plan" in msg.get("content", "") for msg in messages):
+            call_count[0] += 1
+            return f"Attempt {call_count[0]}: I need more time to think.\n\nNOT READY: I need to refine my plan further."
+        return "This is an unsolved problem in mathematics."
+
+    agent.llm.call = mock_llm_call
+
     result = agent.execute_task(task)
 
-    assert result is not None
-    # Area = pi * r^2 = 3.14 * 25 = 78.5
-    assert "78" in str(result) or "79" in str(result)
-    assert "Planning:" in task.description
+    assert result == "This is an unsolved problem in mathematics."
+    assert (
+        call_count[0] == 2
+    )  # Should have made exactly 2 reasoning calls (max_attempts)
+    assert "Reasoning Plan:" in task.description
+
+
+def test_agent_reasoning_error_handling():
+    """Test error handling during the reasoning process."""
+    llm = LLM("gpt-3.5-turbo")
+
+    agent = Agent(
+        role="Test Agent",
+        goal="To test the reasoning feature",
+        backstory="I am a test agent created to verify the reasoning feature works correctly.",
+        llm=llm,
+        reasoning=True,
+    )
+
+    task = Task(
+        description="Task that will cause an error",
+        expected_output="Output that will never be generated",
+        agent=agent,
+    )
+
+    call_count = [0]
+
+    def mock_llm_call_error(*args, **kwargs):
+        call_count[0] += 1
+        if call_count[0] <= 2:  # First calls are for reasoning
+            raise Exception("LLM error during reasoning")
+        return "Fallback execution result"  # Return a value for task execution
+
+    agent.llm.call = mock_llm_call_error
+
+    result = agent.execute_task(task)
+
+    assert result == "Fallback execution result"
+    assert call_count[0] > 2  # Ensure we called the mock multiple times
+
+
+@pytest.mark.skip(reason="Test requires updates for native tool calling changes")
+def test_agent_with_function_calling():
+    """Test agent with reasoning using function calling."""
+    llm = LLM("gpt-3.5-turbo")
+
+    agent = Agent(
+        role="Test Agent",
+        goal="To test the reasoning feature",
+        backstory="I am a test agent created to verify the reasoning feature works correctly.",
+        llm=llm,
+        reasoning=True,
+        verbose=True,
+    )
+
+    task = Task(
+        description="Simple math task: What's 2+2?",
+        expected_output="The answer should be a number.",
+        agent=agent,
+    )
+
+    agent.llm.supports_function_calling = lambda: True
+
+    def mock_function_call(messages, *args, **kwargs):
+        if "tools" in kwargs:
+            return json.dumps(
+                {"plan": "I'll solve this simple math problem: 2+2=4.", "ready": True}
+            )
+        return "4"
+
+    agent.llm.call = mock_function_call
+
+    result = agent.execute_task(task)
+
+    assert result == "4"
+    assert "Reasoning Plan:" in task.description
+    assert "I'll solve this simple math problem: 2+2=4." in task.description
+
+
+@pytest.mark.skip(reason="Test requires updates for native tool calling changes")
+def test_agent_with_function_calling_fallback():
+    """Test agent with reasoning using function calling that falls back to text parsing."""
+    llm = LLM("gpt-3.5-turbo")
+
+    agent = Agent(
+        role="Test Agent",
+        goal="To test the reasoning feature",
+        backstory="I am a test agent created to verify the reasoning feature works correctly.",
+        llm=llm,
+        reasoning=True,
+        verbose=True,
+    )
+
+    task = Task(
+        description="Simple math task: What's 2+2?",
+        expected_output="The answer should be a number.",
+        agent=agent,
+    )
+
+    agent.llm.supports_function_calling = lambda: True
+
+    def mock_function_call(messages, *args, **kwargs):
+        if "tools" in kwargs:
+            return "Invalid JSON that will trigger fallback. READY: I am ready to execute the task."
+        return "4"
+
+    agent.llm.call = mock_function_call
+
+    result = agent.execute_task(task)
+
+    assert result == "4"
+    assert "Reasoning Plan:" in task.description
+    assert "Invalid JSON that will trigger fallback" in task.description

lib/crewai/tests/agents/test_native_tool_calling.py

@@ -1184,7 +1184,7 @@ class TestNativeToolCallingJsonParseError:
         executor = self._make_executor([tool])
 
         from crewai.utilities.agent_utils import convert_tools_to_openai_schema
-        _, available_functions, _ = convert_tools_to_openai_schema([tool])
+        _, available_functions = convert_tools_to_openai_schema([tool])
 
         malformed_json = '{"code": "print("hello")"}'
 
@@ -1212,7 +1212,7 @@ class TestNativeToolCallingJsonParseError:
         executor = self._make_executor([tool])
 
         from crewai.utilities.agent_utils import convert_tools_to_openai_schema
-        _, available_functions, _ = convert_tools_to_openai_schema([tool])
+        _, available_functions = convert_tools_to_openai_schema([tool])
 
         valid_json = '{"code": "print(1)"}'
 
@@ -1239,7 +1239,7 @@ class TestNativeToolCallingJsonParseError:
         executor = self._make_executor([tool])
 
         from crewai.utilities.agent_utils import convert_tools_to_openai_schema
-        _, available_functions, _ = convert_tools_to_openai_schema([tool])
+        _, available_functions = convert_tools_to_openai_schema([tool])
 
         result = executor._execute_single_native_tool_call(
             call_id="call_789",
@@ -1265,7 +1265,7 @@ class TestNativeToolCallingJsonParseError:
         executor = self._make_executor([tool])
 
         from crewai.utilities.agent_utils import convert_tools_to_openai_schema
-        _, available_functions, _ = convert_tools_to_openai_schema([tool])
+        _, available_functions = convert_tools_to_openai_schema([tool])
 
         result = executor._execute_single_native_tool_call(
             call_id="call_schema",

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_agent_kickoff_with_planning_stores_plan_in_state.yaml

@@ -1,234 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
-      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
-      a focused execution plan for the following task:\n\n## Task\nWhat is 2 + 2?\n\n##
-      Expected Output\nComplete the task successfully\n\n## Available Tools\nNo tools
-      available\n\n## Instructions\nCreate ONLY the essential steps needed to complete
-      this task. Use the MINIMUM number of steps required - do NOT pad your plan with
-      unnecessary steps. Most tasks need only 2-5 steps.\n\nFor each step:\n- State
-      the specific action to take\n- Specify which tool to use (if any)\n\nDo NOT
-      include:\n- Setup or preparation steps that are obvious\n- Verification steps
-      unless critical\n- Documentation or cleanup steps unless explicitly required\n-
-      Generic steps like \"review results\" or \"finalize output\"\n\nAfter your plan,
-      state:\n- \"READY: I am ready to execute the task.\" if the plan is complete\n-
-      \"NOT READY: I need to refine my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
-      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
-      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
-      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1541'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTTAh68P65LybtqkwNI3p2HXcRv\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078147,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"## Execution Plan\\n\\n1. **Action:**
-        Perform the addition operation.  \\n   **Tool:** None (manually calculate).\\n\\n2.
-        **Action:** State the result.  \\n   **Tool:** None (manually output).\\n\\nREADY:
-        I am ready to execute the task.\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 281,\n    \"completion_tokens\":
-        56,\n    \"total_tokens\": 337,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:28 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '1165'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
-      assistant that solves math problems step by step\nYour personal goal is: Help
-      solve simple math problems"},{"role":"user","content":"\nCurrent Task: What
-      is 2 + 2?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '299'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTVB9mdtq1YZrUVf1aSb6dVVQ8G\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078149,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"To solve the problem of 2 + 2, we simply
-        perform the addition:\\n\\n1. Start with the first number: 2\\n2. Add the
-        second number: + 2\\n3. Combine the two: 2 + 2 = 4\\n\\nTherefore, the answer
-        is 4.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n
-        \     \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n
-        \ \"usage\": {\n    \"prompt_tokens\": 54,\n    \"completion_tokens\": 62,\n
-        \   \"total_tokens\": 116,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:30 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '1300'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_agent_kickoff_without_planning_skips_plan_generation.yaml

@@ -1,108 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
-      assistant\nYour personal goal is: Help solve simple math problems"},{"role":"user","content":"\nCurrent
-      Task: What is 3 + 3?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '260'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTTFxQ75llVmJv0ee902FIjXE8p\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078147,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"3 + 3 equals 6.\",\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        47,\n    \"completion_tokens\": 8,\n    \"total_tokens\": 55,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:27 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '401'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_executor_state_contains_plan_after_planning.yaml

@@ -1,230 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
-      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
-      a focused execution plan for the following task:\n\n## Task\nWhat is 7 + 7?\n\n##
-      Expected Output\nComplete the task successfully\n\n## Available Tools\nNo tools
-      available\n\n## Instructions\nCreate ONLY the essential steps needed to complete
-      this task. Use the MINIMUM number of steps required - do NOT pad your plan with
-      unnecessary steps. Most tasks need only 2-5 steps.\n\nFor each step:\n- State
-      the specific action to take\n- Specify which tool to use (if any)\n\nDo NOT
-      include:\n- Setup or preparation steps that are obvious\n- Verification steps
-      unless critical\n- Documentation or cleanup steps unless explicitly required\n-
-      Generic steps like \"review results\" or \"finalize output\"\n\nAfter your plan,
-      state:\n- \"READY: I am ready to execute the task.\" if the plan is complete\n-
-      \"NOT READY: I need to refine my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
-      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
-      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
-      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1541'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTdqlxwWowSdLncBERFrCgxTvVj\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078157,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"## Execution Plan\\n\\n1. Calculate
-        the sum of 7 and 7.\\n   \\nREADY: I am ready to execute the task.\",\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        281,\n    \"completion_tokens\": 28,\n    \"total_tokens\": 309,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:38 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '709'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
-      assistant that solves math problems step by step\nYour personal goal is: Help
-      solve simple math problems"},{"role":"user","content":"\nCurrent Task: What
-      is 7 + 7?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '299'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTeB6Miecallw9SjSfLAXPjX2XD\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078158,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"To find the sum of 7 and 7, you simply
-        add the two numbers together:\\n\\n7 + 7 = 14\\n\\nSo, the answer is 14.\",\n
-        \       \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\":
-        null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        54,\n    \"completion_tokens\": 35,\n    \"total_tokens\": 89,\n    \"prompt_tokens_details\":
-        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
-        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
-        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
-        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:38 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '733'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_planning_config_disabled_skips_planning.yaml

@@ -1,108 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
-      assistant\nYour personal goal is: Help solve simple math problems"},{"role":"user","content":"\nCurrent
-      Task: What is 5 + 5?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '260'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTf8T2iADffpPCJBZhntLlaoaSy\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078159,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"5 + 5 equals 10.\",\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        47,\n    \"completion_tokens\": 8,\n    \"total_tokens\": 55,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:40 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '515'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_planning_creates_minimal_steps_for_multi_step_task.yaml

@@ -1,247 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
-      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
-      a focused execution plan for the following task:\n\n## Task\nCalculate the sum
-      of the first 3 prime numbers, then multiply that result by 2. Show your work
-      for each step.\n\n## Expected Output\nComplete the task successfully\n\n## Available
-      Tools\nNo tools available\n\n## Instructions\nCreate ONLY the essential steps
-      needed to complete this task. Use the MINIMUM number of steps required - do
-      NOT pad your plan with unnecessary steps. Most tasks need only 2-5 steps.\n\nFor
-      each step:\n- State the specific action to take\n- Specify which tool to use
-      (if any)\n\nDo NOT include:\n- Setup or preparation steps that are obvious\n-
-      Verification steps unless critical\n- Documentation or cleanup steps unless
-      explicitly required\n- Generic steps like \"review results\" or \"finalize output\"\n\nAfter
-      your plan, state:\n- \"READY: I am ready to execute the task.\" if the plan
-      is complete\n- \"NOT READY: I need to refine my plan because [reason].\" if
-      you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
-      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
-      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
-      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1636'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTWa7FxCHkHwHF25AYXXeJDBOuY\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078150,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"## Execution Plan\\n\\n1. Identify
-        the first 3 prime numbers: 2, 3, and 5.\\n2. Calculate the sum: \\\\(2 + 3
-        + 5 = 10\\\\).\\n3. Multiply the sum by 2: \\\\(10 \\\\times 2 = 20\\\\).\\n\\nREADY:
-        I am ready to execute the task.\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 299,\n    \"completion_tokens\":
-        74,\n    \"total_tokens\": 373,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:32 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '1716'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Tutor. An expert
-      math tutor who breaks down problems step by step\nYour personal goal is: Solve
-      multi-step math problems accurately"},{"role":"user","content":"\nCurrent Task:
-      Calculate the sum of the first 3 prime numbers, then multiply that result by
-      2. Show your work for each step.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '400'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTYJgCZf2oY7wiPMZmN4QEQhHb5\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078152,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"To solve the problem, let's break it
-        down into two main steps: \\n\\n1. Calculate the sum of the first 3 prime
-        numbers.\\n2. Multiply the result of that sum by 2.\\n\\n### Step 1: Identify
-        the first 3 prime numbers\\nPrime numbers are natural numbers greater than
-        1 that have no positive divisors other than 1 and themselves. \\n\\nThe first
-        three prime numbers are:\\n- 2\\n- 3\\n- 5\\n\\n### Step 2: Calculate the
-        sum of the first 3 prime numbers\\nNow, we add these prime numbers together:\\n\\n\\\\[\\n2
-        + 3 + 5\\n\\\\]\\n\\nCalculating this step-by-step:\\n- First, add 2 and 3:\\n
-        \ \\\\[\\n  2 + 3 = 5\\n  \\\\]\\n  \\n- Next, add this result to 5:\\n  \\\\[\\n
-        \ 5 + 5 = 10\\n  \\\\]\\n\\nSo, the sum of the first 3 prime numbers is \\\\(10\\\\).\\n\\n###
-        Step 3: Multiply the sum by 2\\nNext, we take the sum we calculated and multiply
-        it by 2:\\n\\n\\\\[\\n10 \\\\times 2\\n\\\\]\\n\\nCalculating this:\\n\\\\[\\n10
-        \\\\times 2 = 20\\n\\\\]\\n\\n### Final Answer\\nThus, the final result obtained
-        after performing all the steps is:\\n\\n\\\\[\\n\\\\boxed{20}\\n\\\\]\",\n
-        \       \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\":
-        null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        74,\n    \"completion_tokens\": 288,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:37 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '4751'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_planning_disabled_skips_planning.yaml

@@ -1,108 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
-      assistant\nYour personal goal is: Help solve simple math problems"},{"role":"user","content":"\nCurrent
-      Task: What is 5 + 5?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '260'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yXGD5IrieoUDSK5hDmJyA2gJtDc\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078382,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"5 + 5 equals 10.\",\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        47,\n    \"completion_tokens\": 8,\n    \"total_tokens\": 55,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:26:23 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '363'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_planning_handles_sequential_dependency_task.yaml

@@ -1,242 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
-      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
-      a focused execution plan for the following task:\n\n## Task\nConvert 100 degrees
-      Celsius to Fahrenheit, then round the result to the nearest 10.\n\n## Expected
-      Output\nComplete the task successfully\n\n## Available Tools\nNo tools available\n\n##
-      Instructions\nCreate ONLY the essential steps needed to complete this task.
-      Use the MINIMUM number of steps required - do NOT pad your plan with unnecessary
-      steps. Most tasks need only 2-5 steps.\n\nFor each step:\n- State the specific
-      action to take\n- Specify which tool to use (if any)\n\nDo NOT include:\n- Setup
-      or preparation steps that are obvious\n- Verification steps unless critical\n-
-      Documentation or cleanup steps unless explicitly required\n- Generic steps like
-      \"review results\" or \"finalize output\"\n\nAfter your plan, state:\n- \"READY:
-      I am ready to execute the task.\" if the plan is complete\n- \"NOT READY: I
-      need to refine my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
-      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
-      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
-      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1610'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTN8fHOefyzzhvdUOHjxdFDR2HW\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078141,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"## Execution Plan\\n\\n1. Convert 100
-        degrees Celsius to Fahrenheit using the formula: \\\\( F = C \\\\times \\\\frac{9}{5}
-        + 32 \\\\).\\n2. Round the Fahrenheit result to the nearest 10.\\n\\nREADY:
-        I am ready to execute the task.\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 291,\n    \"completion_tokens\":
-        58,\n    \"total_tokens\": 349,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:22 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '1089'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Unit Converter. A precise
-      unit conversion specialist\nYour personal goal is: Accurately convert between
-      units and apply transformations"},{"role":"user","content":"\nCurrent Task:
-      Convert 100 degrees Celsius to Fahrenheit, then round the result to the nearest
-      10.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '373'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTPQewXDyPdYHI4dHPH7YGHcRge\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078143,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"To convert degrees Celsius to Fahrenheit,
-        you can use the formula:\\n\\n\\\\[ F = \\\\left( C \\\\times \\\\frac{9}{5}
-        \\\\right) + 32 \\\\]\\n\\nPlugging in 100 degrees Celsius:\\n\\n\\\\[ F =
-        \\\\left( 100 \\\\times \\\\frac{9}{5} \\\\right) + 32 \\\\]\\n\\nCalculating
-        that step-by-step:\\n\\n1. Multiply 100 by 9: \\n   \\\\[ 100 \\\\times 9
-        = 900 \\\\]\\n\\n2. Divide by 5:\\n   \\\\[ 900 \\\\div 5 = 180 \\\\]\\n\\n3.
-        Add 32:\\n   \\\\[ 180 + 32 = 212 \\\\]\\n\\nSo, 100 degrees Celsius is equal
-        to 212 degrees Fahrenheit.\\n\\nNow, rounding 212 to the nearest 10:\\n\\nThe
-        nearest multiple of 10 to 212 is 210.\\n\\nTherefore, the final result is
-        **210 degrees Fahrenheit**.\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 63,\n    \"completion_tokens\":
-        191,\n    \"total_tokens\": 254,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:26 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '3736'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/test_agent_execute_task_basic.yaml

@@ -1,10 +1,6 @@
 interactions:
 - request:
-    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour
-      personal goal is: test goal"},{"role":"user","content":"\nCurrent Task: Calculate
-      2 + 2\n\nThis is the expected criteria for your final answer: The result of
-      the calculation\nyou MUST return the actual complete content as the final answer,
-      not a summary.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour personal goal is: test goal\nTo give my best complete final answer to the task 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: Calculate 2 + 2\n\nThis is the expected criteria for your final answer: The result of the calculation\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"}'
     headers:
       User-Agent:
       - X-USER-AGENT-XXX
@@ -17,7 +13,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '396'
+      - '797'
       content-type:
       - application/json
       host:
@@ -39,23 +35,13 @@ interactions:
       x-stainless-runtime:
       - CPython
       x-stainless-runtime-version:
-      - 3.13.3
+      - 3.12.10
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-D5DTjYe6n92Rjo4Ox6NiZpAAdBLF0\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770135823,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"The result of the calculation 2 + 2
-        is 4.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n
-        \     \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n
-        \ \"usage\": {\n    \"prompt_tokens\": 75,\n    \"completion_tokens\": 14,\n
-        \   \"total_tokens\": 89,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
-        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
-        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
-        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
-        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+      string: "{\n  \"id\": \"chatcmpl-CjDsYJQa2tIYBbNloukSWecpsTvdK\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764894146,\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: The result of the calculation 2 + 2 is 4.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 161,\n    \"completion_tokens\": 25,\n    \"total_tokens\": 186,\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_11f3029f6b\"\
+        \n}\n"
     headers:
       CF-RAY:
       - CF-RAY-XXX
@@ -64,7 +50,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Tue, 03 Feb 2026 16:23:43 GMT
+      - Fri, 05 Dec 2025 00:22:27 GMT
       Server:
       - cloudflare
       Set-Cookie:
@@ -84,11 +70,13 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '636'
+      - '516'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
       - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '529'
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:

lib/crewai/tests/cassettes/agents/test_agent_execute_task_with_context.yaml

@@ -1,12 +1,6 @@
 interactions:
 - request:
-    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour
-      personal goal is: test goal"},{"role":"user","content":"\nCurrent Task: Summarize
-      the given context in one sentence\n\nThis is the expected criteria for your
-      final answer: A one-sentence summary\nyou MUST return the actual complete content
-      as the final answer, not a summary.\n\nThis is the context you''re working with:\nThe
-      quick brown fox jumps over the lazy dog. This sentence contains every letter
-      of the alphabet.\n\nProvide your complete response:"}],"model":"gpt-3.5-turbo"}'
+    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour personal goal is: test goal\nTo give my best complete final answer to the task 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: Summarize the given context in one sentence\n\nThis is the expected criteria for your final answer: A one-sentence summary\nyou MUST return the actual complete content as the final answer, not a summary.\n\nThis is the context you''re working with:\nThe quick brown fox jumps over the lazy dog. This sentence contains every letter of the alphabet.\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-3.5-turbo"}'
     headers:
       User-Agent:
       - X-USER-AGENT-XXX
@@ -19,7 +13,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '562'
+      - '963'
       content-type:
       - application/json
       host:
@@ -41,23 +35,13 @@ interactions:
       x-stainless-runtime:
       - CPython
       x-stainless-runtime-version:
-      - 3.13.3
+      - 3.12.10
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-D5DTn6yIQ7HpIn5j5Bsbag1efzXPa\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770135827,\n  \"model\": \"gpt-3.5-turbo-0125\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"The quick brown fox jumps over the
-        lazy dog. This sentence contains every letter of the alphabet.\",\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        105,\n    \"completion_tokens\": 19,\n    \"total_tokens\": 124,\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\": null\n}\n"
+      string: "{\n  \"id\": \"chatcmpl-CjDtsaX0LJ0dzZz02KwKeRGYgazv1\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764894228,\n  \"model\": \"gpt-3.5-turbo-0125\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"I now can give a great answer\\n\\nFinal Answer: The quick brown fox jumps over the lazy dog. This sentence contains every letter of the alphabet.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 191,\n    \"completion_tokens\": 30,\n    \"total_tokens\": 221,\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\": null\n}\n"
     headers:
       CF-RAY:
       - CF-RAY-XXX
@@ -66,7 +50,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Tue, 03 Feb 2026 16:23:48 GMT
+      - Fri, 05 Dec 2025 00:23:49 GMT
       Server:
       - cloudflare
       Set-Cookie:
@@ -86,11 +70,13 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '606'
+      - '506'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
       - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '559'
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:

lib/crewai/tests/cassettes/agents/test_agent_execute_task_with_custom_llm.yaml

@@ -1,10 +1,6 @@
 interactions:
 - request:
-    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour
-      personal goal is: test goal"},{"role":"user","content":"\nCurrent Task: Write
-      a haiku about AI\n\nThis is the expected criteria for your final answer: A haiku
-      (3 lines, 5-7-5 syllable pattern) about AI\nyou MUST return the actual complete
-      content as the final answer, not a summary.\n\nProvide your complete response:"}],"model":"gpt-3.5-turbo","max_tokens":50,"temperature":0.7}'
+    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour personal goal is: test goal\nTo give my best complete final answer to the task 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: Write a haiku about AI\n\nThis is the expected criteria for your final answer: A haiku (3 lines, 5-7-5 syllable pattern) about AI\nyou MUST return the actual complete content as the final answer, not a summary.\n\nBegin! This is VERY important to you, use the tools available and give your best Final Answer, your job depends on it!\n\nThought:"}],"model":"gpt-3.5-turbo","max_tokens":50,"temperature":0.7}'
     headers:
       User-Agent:
       - X-USER-AGENT-XXX
@@ -17,7 +13,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '460'
+      - '861'
       content-type:
       - application/json
       host:
@@ -39,23 +35,13 @@ interactions:
       x-stainless-runtime:
       - CPython
       x-stainless-runtime-version:
-      - 3.13.3
+      - 3.12.10
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-D5DTgAqxaC8RmEvikXK0UDaxmVmf9\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770135820,\n  \"model\": \"gpt-3.5-turbo-0125\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"Artificial minds,\\nCode and circuits
-        intertwine,\\nFuture undefined.\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 88,\n    \"completion_tokens\":
-        13,\n    \"total_tokens\": 101,\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\": null\n}\n"
+      string: "{\n  \"id\": \"chatcmpl-CjDqr2BmEXQ08QzZKslTZJZ5vV9lo\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764894041,\n  \"model\": \"gpt-3.5-turbo-0125\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"I now can give a great answer\\n\\nFinal Answer:  \\nIn circuits they thrive,  \\nArtificial minds awake,  \\nFuture's coded drive.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 174,\n    \"completion_tokens\": 29,\n    \"total_tokens\": 203,\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\": null\n}\n"
     headers:
       CF-RAY:
       - CF-RAY-XXX
@@ -64,7 +50,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Tue, 03 Feb 2026 16:23:40 GMT
+      - Fri, 05 Dec 2025 00:20:41 GMT
       Server:
       - cloudflare
       Set-Cookie:
@@ -84,11 +70,13 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '277'
+      - '434'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
       - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '456'
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:

lib/crewai/tests/cassettes/agents/test_agent_execute_task_with_planning.yaml

@@ -1,231 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
-      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
-      a focused execution plan for the following task:\n\n## Task\nWhat is 9 + 11?\n\n##
-      Expected Output\nA number\n\n## Available Tools\nNo tools available\n\n## Instructions\nCreate
-      ONLY the essential steps needed to complete this task. Use the MINIMUM number
-      of steps required - do NOT pad your plan with unnecessary steps. Most tasks
-      need only 2-5 steps.\n\nFor each step:\n- State the specific action to take\n-
-      Specify which tool to use (if any)\n\nDo NOT include:\n- Setup or preparation
-      steps that are obvious\n- Verification steps unless critical\n- Documentation
-      or cleanup steps unless explicitly required\n- Generic steps like \"review results\"
-      or \"finalize output\"\n\nAfter your plan, state:\n- \"READY: I am ready to
-      execute the task.\" if the plan is complete\n- \"NOT READY: I need to refine
-      my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
-      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
-      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
-      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1520'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yVACNTzZcghQRwt5kFYQ4HAvbgI\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078252,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"## Execution Plan\\n1. Calculate the
-        sum of 9 and 11.\\n   \\nREADY: I am ready to execute the task.\",\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        279,\n    \"completion_tokens\": 28,\n    \"total_tokens\": 307,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:24:13 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '951'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
-      math tutor\nYour personal goal is: Help solve math problems"},{"role":"user","content":"\nCurrent
-      Task: What is 9 + 11?\n\nPlanning:\n## Execution Plan\n1. Calculate the sum
-      of 9 and 11.\n   \nREADY: I am ready to execute the task.\n\nThis is the expected
-      criteria for your final answer: A number\nyou MUST return the actual complete
-      content as the final answer, not a summary.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '513'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yVBdTCKSdfcJYlIOX9BbzrObgFI\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078253,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"9 + 11 = 20\",\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        105,\n    \"completion_tokens\": 7,\n    \"total_tokens\": 112,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:24:13 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '477'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/test_agent_execute_task_with_planning_refine.yaml

@@ -1,243 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
-      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
-      a focused execution plan for the following task:\n\n## Task\nCalculate the area
-      of a circle with radius 5 (use pi = 3.14)\n\n## Expected Output\nThe area as
-      a number\n\n## Available Tools\nNo tools available\n\n## Instructions\nCreate
-      ONLY the essential steps needed to complete this task. Use the MINIMUM number
-      of steps required - do NOT pad your plan with unnecessary steps. Most tasks
-      need only 2-5 steps.\n\nFor each step:\n- State the specific action to take\n-
-      Specify which tool to use (if any)\n\nDo NOT include:\n- Setup or preparation
-      steps that are obvious\n- Verification steps unless critical\n- Documentation
-      or cleanup steps unless explicitly required\n- Generic steps like \"review results\"
-      or \"finalize output\"\n\nAfter your plan, state:\n- \"READY: I am ready to
-      execute the task.\" if the plan is complete\n- \"NOT READY: I need to refine
-      my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
-      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
-      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
-      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1577'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yVCdA1csIzfoHSQvxkfrA4gDn4z\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078254,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"## Execution Plan\\n1. Multiply the
-        radius (5) by itself (5) to get the square of the radius.\\n2. Multiply the
-        squared radius by pi (3.14) to calculate the area.\\n\\nREADY: I am ready
-        to execute the task.\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 293,\n    \"completion_tokens\":
-        54,\n    \"total_tokens\": 347,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:24:15 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '845'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Tutor. An expert
-      tutor\nYour personal goal is: Solve complex math problems step by step"},{"role":"user","content":"\nCurrent
-      Task: Calculate the area of a circle with radius 5 (use pi = 3.14)\n\nPlanning:\n##
-      Execution Plan\n1. Multiply the radius (5) by itself (5) to get the square of
-      the radius.\n2. Multiply the squared radius by pi (3.14) to calculate the area.\n\nREADY:
-      I am ready to execute the task.\n\nThis is the expected criteria for your final
-      answer: The area as a number\nyou MUST return the actual complete content as
-      the final answer, not a summary.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '682'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yVDh2U2xx3qeYHcDQvbetOmVCxb\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078255,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"To calculate the area of a circle with
-        a radius of 5, we will follow the steps outlined in the execution plan.\\n\\n1.
-        **Square the radius**:\\n   \\\\[\\n   5 \\\\times 5 = 25\\n   \\\\]\\n\\n2.
-        **Multiply the squared radius by pi (using \\\\(\\\\pi \\\\approx 3.14\\\\))**:\\n
-        \  \\\\[\\n   \\\\text{Area} = \\\\pi \\\\times (\\\\text{radius})^2 = 3.14
-        \\\\times 25\\n   \\\\]\\n\\n   Now, let's perform the multiplication:\\n
-        \  \\\\[\\n   3.14 \\\\times 25 = 78.5\\n   \\\\]\\n\\nThus, the area of the
-        circle is \\\\( \\\\boxed{78.5} \\\\).\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 147,\n    \"completion_tokens\":
-        155,\n    \"total_tokens\": 302,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:24:18 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '2228'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/test_agent_execute_task_with_tool.yaml

@@ -1,11 +1,7 @@
 interactions:
 - request:
-    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour
-      personal goal is: test goal"},{"role":"user","content":"\nCurrent Task: Use
-      the dummy tool to get a result for ''test query''\n\nThis is the expected criteria
-      for your final answer: The result from the dummy tool\nyou MUST return the actual
-      complete content as the final answer, not a summary."}],"model":"gpt-3.5-turbo","tool_choice":"auto","tools":[{"type":"function","function":{"name":"dummy_tool","description":"Useful
-      for when you need to get a dummy result for a query.","strict":true,"parameters":{"properties":{"query":{"title":"Query","type":"string"}},"required":["query"],"type":"object","additionalProperties":false}}}]}'
+    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour personal goal is: test goal\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\nTool Name: dummy_tool\nTool Arguments: {''query'': {''description'': None, ''type'': ''str''}}\nTool Description: Useful for when you need to get a dummy result for a query.\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 [dummy_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: Use the dummy tool to get a result for ''test query''\n\nThis is the expected criteria for your final answer: The result from the dummy tool\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-3.5-turbo"}'
     headers:
       User-Agent:
       - X-USER-AGENT-XXX
@@ -18,7 +14,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '712'
+      - '1381'
       content-type:
       - application/json
       host:
@@ -40,26 +36,12 @@ interactions:
       x-stainless-runtime:
       - CPython
       x-stainless-runtime-version:
-      - 3.13.3
+      - 3.12.10
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-D5DTlUmKYee1DaS5AqnaUCZ6B14xV\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770135825,\n  \"model\": \"gpt-3.5-turbo-0125\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": null,\n        \"tool_calls\": [\n          {\n
-        \           \"id\": \"call_tBCgelchfQjXXJrrM15MxqGJ\",\n            \"type\":
-        \"function\",\n            \"function\": {\n              \"name\": \"dummy_tool\",\n
-        \             \"arguments\": \"{\\\"query\\\":\\\"test query\\\"}\"\n            }\n
-        \         }\n        ],\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 122,\n    \"completion_tokens\":
-        16,\n    \"total_tokens\": 138,\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\": null\n}\n"
+      string: "{\n  \"id\": \"chatcmpl-CjDrE1Z8bFQjjxI2vDPPKgtOTm28p\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764894064,\n  \"model\": \"gpt-3.5-turbo-0125\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"you should always think about what to do\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 289,\n    \"completion_tokens\": 8,\n    \"total_tokens\": 297,\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\": null\n}\n"
     headers:
       CF-RAY:
       - CF-RAY-XXX
@@ -68,7 +50,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Tue, 03 Feb 2026 16:23:46 GMT
+      - Fri, 05 Dec 2025 00:21:05 GMT
       Server:
       - cloudflare
       Set-Cookie:
@@ -88,124 +70,13 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '694'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour
-      personal goal is: test goal"},{"role":"user","content":"\nCurrent Task: Use
-      the dummy tool to get a result for ''test query''\n\nThis is the expected criteria
-      for your final answer: The result from the dummy tool\nyou MUST return the actual
-      complete content as the final answer, not a summary."},{"role":"assistant","content":null,"tool_calls":[{"id":"call_tBCgelchfQjXXJrrM15MxqGJ","type":"function","function":{"name":"dummy_tool","arguments":"{\"query\":\"test
-      query\"}"}}]},{"role":"tool","tool_call_id":"call_tBCgelchfQjXXJrrM15MxqGJ","name":"dummy_tool","content":"Dummy
-      result for: test query"},{"role":"user","content":"Analyze the tool result.
-      If requirements are met, provide the Final Answer. Otherwise, call the next
-      tool. Deliver only the answer without meta-commentary."}],"model":"gpt-3.5-turbo","tool_choice":"auto","tools":[{"type":"function","function":{"name":"dummy_tool","description":"Useful
-      for when you need to get a dummy result for a query.","strict":true,"parameters":{"properties":{"query":{"title":"Query","type":"string"}},"required":["query"],"type":"object","additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1202'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D5DTmxZJI2Ee7fHNc9dYtQkD7sIY2\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770135826,\n  \"model\": \"gpt-3.5-turbo-0125\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"Dummy result for: test query\",\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        188,\n    \"completion_tokens\": 7,\n    \"total_tokens\": 195,\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\": null\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 16:23:47 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '416'
+      - '379'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
       - '2020-10-01'
+      x-envoy-upstream-service-time:
+      - '399'
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:

lib/crewai/tests/cassettes/agents/test_agent_execute_task_without_planning.yaml

@@ -1,110 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
-      assistant\nYour personal goal is: Help solve math problems"},{"role":"user","content":"\nCurrent
-      Task: What is 12 * 3?\n\nThis is the expected criteria for your final answer:
-      A number\nyou MUST return the actual complete content as the final answer, not
-      a summary.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '400'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yVCw0CGLFmcVvniplwCCt8avtRb\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078254,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"12 * 3 = 36\",\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        75,\n    \"completion_tokens\": 7,\n    \"total_tokens\": 82,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:24:14 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '331'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/test_agent_kickoff_multi_step_task_with_planning.yaml

@@ -1,243 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
-      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
-      a focused execution plan for the following task:\n\n## Task\nFind the first
-      3 prime numbers, add them together, then multiply by 2.\n\n## Expected Output\nComplete
-      the task successfully\n\n## Available Tools\nNo tools available\n\n## Instructions\nCreate
-      ONLY the essential steps needed to complete this task. Use the MINIMUM number
-      of steps required - do NOT pad your plan with unnecessary steps. Most tasks
-      need only 2-5 steps.\n\nFor each step:\n- State the specific action to take\n-
-      Specify which tool to use (if any)\n\nDo NOT include:\n- Setup or preparation
-      steps that are obvious\n- Verification steps unless critical\n- Documentation
-      or cleanup steps unless explicitly required\n- Generic steps like \"review results\"
-      or \"finalize output\"\n\nAfter your plan, state:\n- \"READY: I am ready to
-      execute the task.\" if the plan is complete\n- \"NOT READY: I need to refine
-      my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
-      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
-      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
-      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1597'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yU0MD5GfSUjRW0R4cBmFJ6Hcjbi\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078180,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"### Execution Plan\\n1. Identify the
-        first 3 prime numbers: 2, 3, and 5.\\n2. Add the prime numbers together: 2
-        + 3 + 5 = 10.\\n3. Multiply the sum by 2: 10 * 2 = 20.\\n\\nREADY: I am ready
-        to execute the task.\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 291,\n    \"completion_tokens\":
-        73,\n    \"total_tokens\": 364,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:23:02 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '1253'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Tutor. An expert
-      tutor who explains step by step\nYour personal goal is: Solve multi-step math
-      problems"},{"role":"user","content":"\nCurrent Task: Find the first 3 prime
-      numbers, add them together, then multiply by 2.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '333'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yU2qY6Xqpkz2D5yVAwagQzuPpen\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078182,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"To solve the problem, let\u2019s go
-        through each step methodically.\\n\\n1. **Identify the first three prime numbers**:\\n
-        \  - **Prime numbers** are numbers greater than 1 that have no positive divisors
-        other than 1 and themselves.\\n   - The first three prime numbers are:\\n
-        \    - 2\\n     - 3\\n     - 5\\n\\n2. **Add these prime numbers together**:\\n
-        \  - We add them together:\\n     \\\\[\\n     2 + 3 + 5\\n     \\\\]\\n   -
-        Performing the addition step-by-step:\\n     - First, add 2 and 3:\\n       \\\\[\\n
-        \      2 + 3 = 5\\n       \\\\]\\n     - Then add 5 to this result:\\n       \\\\[\\n
-        \      5 + 5 = 10\\n       \\\\]\\n   - So, the sum of the first three prime
-        numbers is **10**.\\n\\n3. **Multiply the sum by 2**:\\n   - Now we multiply
-        the result by 2:\\n     \\\\[\\n     10 \\\\times 2 = 20\\n     \\\\]\\n  \\nTherefore,
-        the final answer is **20**.\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 62,\n    \"completion_tokens\":
-        236,\n    \"total_tokens\": 298,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:23:06 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '3846'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/test_agent_kickoff_with_planning.yaml

@@ -1,238 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
-      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
-      a focused execution plan for the following task:\n\n## Task\nWhat is 15 + 27?\n\n##
-      Expected Output\nComplete the task successfully\n\n## Available Tools\nNo tools
-      available\n\n## Instructions\nCreate ONLY the essential steps needed to complete
-      this task. Use the MINIMUM number of steps required - do NOT pad your plan with
-      unnecessary steps. Most tasks need only 2-5 steps.\n\nFor each step:\n- State
-      the specific action to take\n- Specify which tool to use (if any)\n\nDo NOT
-      include:\n- Setup or preparation steps that are obvious\n- Verification steps
-      unless critical\n- Documentation or cleanup steps unless explicitly required\n-
-      Generic steps like \"review results\" or \"finalize output\"\n\nAfter your plan,
-      state:\n- \"READY: I am ready to execute the task.\" if the plan is complete\n-
-      \"NOT READY: I need to refine my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
-      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
-      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
-      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1543'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTrm3GkzDX47DIcce9uA3iF8kFE\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078171,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"## Execution Plan\\n\\n1. Calculate
-        the sum of 15 and 27.\\n\\nREADY: I am ready to execute the task.\",\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        281,\n    \"completion_tokens\": 27,\n    \"total_tokens\": 308,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:51 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '691'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
-      math tutor\nYour personal goal is: Help solve math problems step by step"},{"role":"user","content":"\nCurrent
-      Task: What is 15 + 27?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '269'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTrUOvExA9fTFDwYxvG4xEgRP6L\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078171,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"To solve the problem \\\\( 15 + 27
-        \\\\), we can follow these steps:\\n\\n1. **Align the numbers**: Write them
-        one on top of the other, aligned by their rightmost digits:\\n\\n   ```\\n
-        \     15\\n   + 27\\n   ```\\n\\n2. **Add the units place**: Start from the
-        rightmost digits (units place):\\n   - \\\\( 5 + 7 = 12 \\\\)\\n   - Write
-        down 2 and carry over 1.\\n\\n3. **Add the tens place**: Now, move to the
-        next column (tens place):\\n   - \\\\( 1 + 2 + 1 \\\\) (the 1 is from the
-        carry) \\\\( = 4 \\\\)\\n\\n4. **Combine the results**: Now, combine the results
-        from the tens and units places:\\n   - The result in the tens place is 4 and
-        in the units place is 2, giving us \\\\( 42 \\\\).\\n\\nTherefore, \\\\( 15
-        + 27 = 42 \\\\).\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 50,\n    \"completion_tokens\":
-        209,\n    \"total_tokens\": 259,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:55 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '3263'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/test_agent_kickoff_with_planning_disabled.yaml

@@ -1,110 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
-      assistant\nYour personal goal is: Help solve math problems"},{"role":"user","content":"\nCurrent
-      Task: What is 100 / 4?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '255'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yU6mFapBLuCx4fJtYBup52dwwrs\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078186,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"To solve the problem 100 divided by
-        4, you can perform the division as follows:\\n\\n100 \xF7 4 = 25\\n\\nSo,
-        the answer is 25.\",\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 46,\n    \"completion_tokens\":
-        36,\n    \"total_tokens\": 82,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:23:07 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '1098'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/agents/test_agent_kickoff_without_planning.yaml

@@ -1,108 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
-      assistant\nYour personal goal is: Help solve math problems"},{"role":"user","content":"\nCurrent
-      Task: What is 8 * 7?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '253'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D4yTqLFhGtfq2CyS2aPPhiZL4GjtQ\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770078170,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"8 * 7 equals 56.\",\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        46,\n    \"completion_tokens\": 8,\n    \"total_tokens\": 54,\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_1590f93f9d\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 00:22:50 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '443'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/utilities/TestAzureStructuredPlanning.test_azure_research_workflow_generates_steps.yaml

@@ -1,548 +0,0 @@
-interactions:
-- request:
-    body: '{"messages": [{"role": "system", "content": "You are a strategic planning
-      assistant. Create minimal, effective execution plans. Prefer fewer steps over
-      more."}, {"role": "user", "content": "Create a focused execution plan for the
-      following task:\n\n## Task\nResearch the current state of the AI agent market:\n1.
-      Search for recent information about AI agents and their market trends\n2. Read
-      detailed content from a relevant industry source\n3. Generate a brief report
-      summarizing the key findings\n\nUse the available tools for each step.\n\n##
-      Expected Output\nComplete the task successfully\n\n## Available Tools\nweb_search,
-      read_website, generate_report\n\n## Instructions\nCreate ONLY the essential
-      steps needed to complete this task. Use the MINIMUM number of steps required
-      - do NOT pad your plan with unnecessary steps. Most tasks need only 2-5 steps.\n\nFor
-      each step:\n- State the specific action to take\n- Specify which tool to use
-      (if any)\n- Note dependencies on previous steps if this step requires their
-      output\n- If a step involves multiple items (e.g., research 3 competitors),
-      note this explicitly\n\nDo NOT include:\n- Setup or preparation steps that are
-      obvious\n- Verification steps unless critical\n- Documentation or cleanup steps
-      unless explicitly required\n- Generic steps like \"review results\" or \"finalize
-      output\"\n\nAfter your plan, state:\n- \"READY: I am ready to execute the task.\"
-      if the plan is complete\n- \"NOT READY: I need to refine my plan because [reason].\"
-      if you need more thinking"}], "stream": false, "stop": ["\nObservation:"], "tool_choice":
-      "auto", "tools": [{"function": {"name": "create_reasoning_plan", "description":
-      "Create or refine a reasoning plan for a task with structured steps", "parameters":
-      {"type": "object", "properties": {"plan": {"type": "string", "description":
-      "A brief summary of the overall plan."}, "steps": {"type": "array", "description":
-      "List of discrete steps to execute the plan", "items": {"type": "object", "properties":
-      {"step_number": {"type": "integer", "description": "Step number (1-based)"},
-      "description": {"type": "string", "description": "What to do in this step"},
-      "tool_to_use": {"type": ["string", "null"], "description": "Tool to use for
-      this step, or null if no tool needed"}, "depends_on": {"type": "array", "items":
-      {"type": "integer"}, "description": "Step numbers this step depends on (empty
-      array if none)"}}, "required": ["step_number", "description", "tool_to_use",
-      "depends_on"], "additionalProperties": false}}, "ready": {"type": "boolean",
-      "description": "Whether the agent is ready to execute the task."}}, "required":
-      ["plan", "steps", "ready"], "additionalProperties": false}}, "type": "function"}]}'
-    headers:
-      Accept:
-      - application/json
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '2711'
-      Content-Type:
-      - application/json
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      api-key:
-      - X-API-KEY-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      x-ms-client-request-id:
-      - X-MS-CLIENT-REQUEST-ID-XXX
-    method: POST
-    uri: https://fake-azure-endpoint.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2024-12-01-preview
-  response:
-    body:
-      string: '{"choices":[{"content_filter_results":{},"finish_reason":"tool_calls","index":0,"logprobs":null,"message":{"annotations":[],"content":null,"refusal":null,"role":"assistant","tool_calls":[{"function":{"arguments":"{\"plan\":\"Research
-        the current state of the AI agent market and summarize the key findings.\",\"steps\":[{\"step_number\":1,\"description\":\"Search
-        for recent information about AI agents and their market trends using web_search.\",\"tool_to_use\":\"web_search\",\"depends_on\":[]},{\"step_number\":2,\"description\":\"Read
-        detailed content from a relevant industry source using read_website, gathering
-        insights on trends and competitive analysis.\",\"tool_to_use\":\"read_website\",\"depends_on\":[1]},{\"step_number\":3,\"description\":\"Using
-        the knowledge from steps 1 and 2, generate a brief report summarizing the
-        AI agent market findings.\",\"tool_to_use\":\"generate_report\",\"depends_on\":[1,2]}],\"ready\":true}","name":"create_reasoning_plan"},"id":"call_TPmou69xLfxPqApRnPwI6zYV","type":"function"}]}}],"created":1770145131,"id":"chatcmpl-D5Ftr1QP6lTPXIemws2EtuKaWeSxt","model":"gpt-4o-2024-11-20","object":"chat.completion","prompt_filter_results":[{"prompt_index":0,"content_filter_results":{"hate":{"filtered":false,"severity":"safe"},"jailbreak":{"detected":false,"filtered":false},"self_harm":{"filtered":false,"severity":"safe"},"sexual":{"filtered":false,"severity":"safe"},"violence":{"filtered":false,"severity":"safe"}}}],"system_fingerprint":"fp_b54fe76834","usage":{"completion_tokens":157,"completion_tokens_details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0},"prompt_tokens":480,"prompt_tokens_details":{"audio_tokens":0,"cached_tokens":0},"total_tokens":637}}
-
-        '
-    headers:
-      Content-Length:
-      - '1762'
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 18:58:54 GMT
-      Strict-Transport-Security:
-      - STS-XXX
-      apim-request-id:
-      - APIM-REQUEST-ID-XXX
-      azureml-model-session:
-      - AZUREML-MODEL-SESSION-XXX
-      x-accel-buffering:
-      - 'no'
-      x-content-type-options:
-      - X-CONTENT-TYPE-XXX
-      x-ms-client-request-id:
-      - X-MS-CLIENT-REQUEST-ID-XXX
-      x-ms-deployment-name:
-      - gpt-4o
-      x-ms-rai-invoked:
-      - 'true'
-      x-ms-region:
-      - X-MS-REGION-XXX
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages": [{"role": "system", "content": "You are Research Analyst.
-      An experienced analyst skilled at gathering information and synthesizing findings
-      into actionable insights.\nYour personal goal is: Conduct thorough research
-      and produce insightful reports"}, {"role": "user", "content": "\nCurrent Task:
-      Research the current state of the AI agent market:\n1. Search for recent information
-      about AI agents and their market trends\n2. Read detailed content from a relevant
-      industry source\n3. Generate a brief report summarizing the key findings\n\nUse
-      the available tools for each step."}], "stream": false, "stop": ["\nObservation:"],
-      "tool_choice": "auto", "tools": [{"function": {"name": "web_search", "description":
-      "Search the web for information on a given topic.\n\nArgs:\n    query: The search
-      query to look up.\n\nReturns:\n    Search results as a string.", "parameters":
-      {"properties": {"query": {"title": "Query", "type": "string"}}, "required":
-      ["query"], "type": "object", "additionalProperties": false}}, "type": "function"},
-      {"function": {"name": "read_website", "description": "Read and extract content
-      from a website URL.\n\nArgs:\n    url: The URL of the website to read.\n\nReturns:\n    The
-      extracted content from the website.", "parameters": {"properties": {"url": {"title":
-      "Url", "type": "string"}}, "required": ["url"], "type": "object", "additionalProperties":
-      false}}, "type": "function"}, {"function": {"name": "generate_report", "description":
-      "Generate a structured report based on research findings.\n\nArgs:\n    title:
-      The title of the report.\n    findings: The research findings to include.\n\nReturns:\n    A
-      formatted report string.", "parameters": {"properties": {"title": {"title":
-      "Title", "type": "string"}, "findings": {"title": "Findings", "type": "string"}},
-      "required": ["title", "findings"], "type": "object", "additionalProperties":
-      false}}, "type": "function"}]}'
-    headers:
-      Accept:
-      - application/json
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '1912'
-      Content-Type:
-      - application/json
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      api-key:
-      - X-API-KEY-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      x-ms-client-request-id:
-      - X-MS-CLIENT-REQUEST-ID-XXX
-    method: POST
-    uri: https://fake-azure-endpoint.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2024-12-01-preview
-  response:
-    body:
-      string: '{"choices":[{"content_filter_results":{},"finish_reason":"tool_calls","index":0,"logprobs":null,"message":{"annotations":[],"content":null,"refusal":null,"role":"assistant","tool_calls":[{"function":{"arguments":"{\"query\":\"current
-        state of AI agent market 2023\"}","name":"web_search"},"id":"call_6RDgkQSr8S7luEHqqOaI734w","type":"function"}]}}],"created":1770145136,"id":"chatcmpl-D5FtwVvV3KE10L2JIOd7n8Ph1Iu3Q","model":"gpt-4o-2024-11-20","object":"chat.completion","prompt_filter_results":[{"prompt_index":0,"content_filter_results":{"hate":{"filtered":false,"severity":"safe"},"jailbreak":{"detected":false,"filtered":false},"self_harm":{"filtered":false,"severity":"safe"},"sexual":{"filtered":false,"severity":"safe"},"violence":{"filtered":false,"severity":"safe"}}}],"system_fingerprint":"fp_b54fe76834","usage":{"completion_tokens":23,"completion_tokens_details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0},"prompt_tokens":267,"prompt_tokens_details":{"audio_tokens":0,"cached_tokens":0},"total_tokens":290}}
-
-        '
-    headers:
-      Content-Length:
-      - '1079'
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 18:58:55 GMT
-      Strict-Transport-Security:
-      - STS-XXX
-      apim-request-id:
-      - APIM-REQUEST-ID-XXX
-      azureml-model-session:
-      - AZUREML-MODEL-SESSION-XXX
-      x-accel-buffering:
-      - 'no'
-      x-content-type-options:
-      - X-CONTENT-TYPE-XXX
-      x-ms-client-request-id:
-      - X-MS-CLIENT-REQUEST-ID-XXX
-      x-ms-deployment-name:
-      - gpt-4o
-      x-ms-rai-invoked:
-      - 'true'
-      x-ms-region:
-      - X-MS-REGION-XXX
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages": [{"role": "system", "content": "You are Research Analyst.
-      An experienced analyst skilled at gathering information and synthesizing findings
-      into actionable insights.\nYour personal goal is: Conduct thorough research
-      and produce insightful reports"}, {"role": "user", "content": "\nCurrent Task:
-      Research the current state of the AI agent market:\n1. Search for recent information
-      about AI agents and their market trends\n2. Read detailed content from a relevant
-      industry source\n3. Generate a brief report summarizing the key findings\n\nUse
-      the available tools for each step."}, {"role": "assistant", "content": "", "tool_calls":
-      [{"id": "call_6RDgkQSr8S7luEHqqOaI734w", "type": "function", "function": {"name":
-      "web_search", "arguments": "{\"query\":\"current state of AI agent market 2023\"}"}}]},
-      {"role": "tool", "tool_call_id": "call_6RDgkQSr8S7luEHqqOaI734w", "content":
-      "Search results for ''current state of AI agent market 2023'': Found 3 relevant
-      articles about the topic including market analysis, competitor data, and industry
-      trends."}], "stream": false, "stop": ["\nObservation:"], "tool_choice": "auto",
-      "tools": [{"function": {"name": "web_search", "description": "Search the web
-      for information on a given topic.\n\nArgs:\n    query: The search query to look
-      up.\n\nReturns:\n    Search results as a string.", "parameters": {"properties":
-      {"query": {"title": "Query", "type": "string"}}, "required": ["query"], "type":
-      "object", "additionalProperties": false}}, "type": "function"}, {"function":
-      {"name": "read_website", "description": "Read and extract content from a website
-      URL.\n\nArgs:\n    url: The URL of the website to read.\n\nReturns:\n    The
-      extracted content from the website.", "parameters": {"properties": {"url": {"title":
-      "Url", "type": "string"}}, "required": ["url"], "type": "object", "additionalProperties":
-      false}}, "type": "function"}, {"function": {"name": "generate_report", "description":
-      "Generate a structured report based on research findings.\n\nArgs:\n    title:
-      The title of the report.\n    findings: The research findings to include.\n\nReturns:\n    A
-      formatted report string.", "parameters": {"properties": {"title": {"title":
-      "Title", "type": "string"}, "findings": {"title": "Findings", "type": "string"}},
-      "required": ["title", "findings"], "type": "object", "additionalProperties":
-      false}}, "type": "function"}]}'
-    headers:
-      Accept:
-      - application/json
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '2381'
-      Content-Type:
-      - application/json
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      api-key:
-      - X-API-KEY-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      x-ms-client-request-id:
-      - X-MS-CLIENT-REQUEST-ID-XXX
-    method: POST
-    uri: https://fake-azure-endpoint.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2024-12-01-preview
-  response:
-    body:
-      string: '{"choices":[{"content_filter_results":{},"finish_reason":"tool_calls","index":0,"logprobs":null,"message":{"annotations":[],"content":null,"refusal":null,"role":"assistant","tool_calls":[{"function":{"arguments":"{\"url\":
-        \"https://example.com/article1\"}","name":"read_website"},"id":"call_ie6tNHSbW9TWIqoXD9CN3MNZ","type":"function"},{"function":{"arguments":"{\"url\":
-        \"https://example.com/article2\"}","name":"read_website"},"id":"call_qxn4V4mMMpOnYSAwVuwarFkB","type":"function"},{"function":{"arguments":"{\"url\":
-        \"https://example.com/article3\"}","name":"read_website"},"id":"call_7ElzUIHHJvuciFWj6eIF5RhF","type":"function"}]}}],"created":1770145137,"id":"chatcmpl-D5Ftxnr2VyEYZd6zSpTJavdxSoE18","model":"gpt-4o-2024-11-20","object":"chat.completion","prompt_filter_results":[{"prompt_index":0,"content_filter_results":{"hate":{"filtered":false,"severity":"safe"},"jailbreak":{"detected":false,"filtered":false},"self_harm":{"filtered":false,"severity":"safe"},"sexual":{"filtered":false,"severity":"safe"},"violence":{"filtered":false,"severity":"safe"}}}],"system_fingerprint":"fp_b54fe76834","usage":{"completion_tokens":77,"completion_tokens_details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0},"prompt_tokens":330,"prompt_tokens_details":{"audio_tokens":0,"cached_tokens":0},"total_tokens":407}}
-
-        '
-    headers:
-      Content-Length:
-      - '1371'
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 18:58:57 GMT
-      Strict-Transport-Security:
-      - STS-XXX
-      apim-request-id:
-      - APIM-REQUEST-ID-XXX
-      azureml-model-session:
-      - AZUREML-MODEL-SESSION-XXX
-      x-accel-buffering:
-      - 'no'
-      x-content-type-options:
-      - X-CONTENT-TYPE-XXX
-      x-ms-client-request-id:
-      - X-MS-CLIENT-REQUEST-ID-XXX
-      x-ms-deployment-name:
-      - gpt-4o
-      x-ms-rai-invoked:
-      - 'true'
-      x-ms-region:
-      - X-MS-REGION-XXX
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages": [{"role": "system", "content": "You are Research Analyst.
-      An experienced analyst skilled at gathering information and synthesizing findings
-      into actionable insights.\nYour personal goal is: Conduct thorough research
-      and produce insightful reports"}, {"role": "user", "content": "\nCurrent Task:
-      Research the current state of the AI agent market:\n1. Search for recent information
-      about AI agents and their market trends\n2. Read detailed content from a relevant
-      industry source\n3. Generate a brief report summarizing the key findings\n\nUse
-      the available tools for each step."}, {"role": "assistant", "content": "", "tool_calls":
-      [{"id": "call_6RDgkQSr8S7luEHqqOaI734w", "type": "function", "function": {"name":
-      "web_search", "arguments": "{\"query\":\"current state of AI agent market 2023\"}"}}]},
-      {"role": "tool", "tool_call_id": "call_6RDgkQSr8S7luEHqqOaI734w", "content":
-      "Search results for ''current state of AI agent market 2023'': Found 3 relevant
-      articles about the topic including market analysis, competitor data, and industry
-      trends."}, {"role": "assistant", "content": "", "tool_calls": [{"id": "call_ie6tNHSbW9TWIqoXD9CN3MNZ",
-      "type": "function", "function": {"name": "read_website", "arguments": "{\"url\":
-      \"https://example.com/article1\"}"}}, {"id": "call_qxn4V4mMMpOnYSAwVuwarFkB",
-      "type": "function", "function": {"name": "read_website", "arguments": "{\"url\":
-      \"https://example.com/article2\"}"}}, {"id": "call_7ElzUIHHJvuciFWj6eIF5RhF",
-      "type": "function", "function": {"name": "read_website", "arguments": "{\"url\":
-      \"https://example.com/article3\"}"}}]}, {"role": "tool", "tool_call_id": "call_ie6tNHSbW9TWIqoXD9CN3MNZ",
-      "content": "Content from https://example.com/article1: This article discusses
-      key insights about the topic including market size ($50B), growth rate (15%
-      YoY), and major players in the industry."}, {"role": "tool", "tool_call_id":
-      "call_qxn4V4mMMpOnYSAwVuwarFkB", "content": "Content from https://example.com/article2:
-      This article discusses key insights about the topic including market size ($50B),
-      growth rate (15% YoY), and major players in the industry."}, {"role": "tool",
-      "tool_call_id": "call_7ElzUIHHJvuciFWj6eIF5RhF", "content": "Content from https://example.com/article3:
-      This article discusses key insights about the topic including market size ($50B),
-      growth rate (15% YoY), and major players in the industry."}], "stream": false,
-      "stop": ["\nObservation:"], "tool_choice": "auto", "tools": [{"function": {"name":
-      "web_search", "description": "Search the web for information on a given topic.\n\nArgs:\n    query:
-      The search query to look up.\n\nReturns:\n    Search results as a string.",
-      "parameters": {"properties": {"query": {"title": "Query", "type": "string"}},
-      "required": ["query"], "type": "object", "additionalProperties": false}}, "type":
-      "function"}, {"function": {"name": "read_website", "description": "Read and
-      extract content from a website URL.\n\nArgs:\n    url: The URL of the website
-      to read.\n\nReturns:\n    The extracted content from the website.", "parameters":
-      {"properties": {"url": {"title": "Url", "type": "string"}}, "required": ["url"],
-      "type": "object", "additionalProperties": false}}, "type": "function"}, {"function":
-      {"name": "generate_report", "description": "Generate a structured report based
-      on research findings.\n\nArgs:\n    title: The title of the report.\n    findings:
-      The research findings to include.\n\nReturns:\n    A formatted report string.",
-      "parameters": {"properties": {"title": {"title": "Title", "type": "string"},
-      "findings": {"title": "Findings", "type": "string"}}, "required": ["title",
-      "findings"], "type": "object", "additionalProperties": false}}, "type": "function"}]}'
-    headers:
-      Accept:
-      - application/json
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '3704'
-      Content-Type:
-      - application/json
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      api-key:
-      - X-API-KEY-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      x-ms-client-request-id:
-      - X-MS-CLIENT-REQUEST-ID-XXX
-    method: POST
-    uri: https://fake-azure-endpoint.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2024-12-01-preview
-  response:
-    body:
-      string: '{"choices":[{"content_filter_results":{},"finish_reason":"tool_calls","index":0,"logprobs":null,"message":{"annotations":[],"content":null,"refusal":null,"role":"assistant","tool_calls":[{"function":{"arguments":"{\"title\":\"Current
-        State of the AI Agent Market\",\"findings\":\"The AI agent market in 2023
-        is valued at $50 billion, with a growth rate of 15% YoY. Major players in
-        the market have been identified as contributing to the expansion of industry
-        capabilities. Trends point to increasing adoption across industries such as
-        healthcare and finance, where automation and intelligence are becoming central
-        to operations. Emerging competitive forces are influencing pricing and technological
-        advancements in AI agents. Existing and new entrants focus on innovation to
-        differentiate their offerings and capture market share.\"}","name":"generate_report"},"id":"call_7eE0bJbpvO6YYQNs87iTifQ3","type":"function"}]}}],"created":1770145138,"id":"chatcmpl-D5Ftys4PE1B1dkTuv6EPOQyqk0xuv","model":"gpt-4o-2024-11-20","object":"chat.completion","prompt_filter_results":[{"prompt_index":0,"content_filter_results":{"hate":{"filtered":false,"severity":"safe"},"jailbreak":{"detected":false,"filtered":false},"self_harm":{"filtered":false,"severity":"safe"},"sexual":{"filtered":false,"severity":"safe"},"violence":{"filtered":false,"severity":"safe"}}}],"system_fingerprint":"fp_b54fe76834","usage":{"completion_tokens":120,"completion_tokens_details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0},"prompt_tokens":537,"prompt_tokens_details":{"audio_tokens":0,"cached_tokens":0},"total_tokens":657}}
-
-        '
-    headers:
-      Content-Length:
-      - '1652'
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 18:58:59 GMT
-      Strict-Transport-Security:
-      - STS-XXX
-      apim-request-id:
-      - APIM-REQUEST-ID-XXX
-      azureml-model-session:
-      - AZUREML-MODEL-SESSION-XXX
-      x-accel-buffering:
-      - 'no'
-      x-content-type-options:
-      - X-CONTENT-TYPE-XXX
-      x-ms-client-request-id:
-      - X-MS-CLIENT-REQUEST-ID-XXX
-      x-ms-deployment-name:
-      - gpt-4o
-      x-ms-rai-invoked:
-      - 'true'
-      x-ms-region:
-      - X-MS-REGION-XXX
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages": [{"role": "system", "content": "You are Research Analyst.
-      An experienced analyst skilled at gathering information and synthesizing findings
-      into actionable insights.\nYour personal goal is: Conduct thorough research
-      and produce insightful reports"}, {"role": "user", "content": "\nCurrent Task:
-      Research the current state of the AI agent market:\n1. Search for recent information
-      about AI agents and their market trends\n2. Read detailed content from a relevant
-      industry source\n3. Generate a brief report summarizing the key findings\n\nUse
-      the available tools for each step."}, {"role": "assistant", "content": "", "tool_calls":
-      [{"id": "call_6RDgkQSr8S7luEHqqOaI734w", "type": "function", "function": {"name":
-      "web_search", "arguments": "{\"query\":\"current state of AI agent market 2023\"}"}}]},
-      {"role": "tool", "tool_call_id": "call_6RDgkQSr8S7luEHqqOaI734w", "content":
-      "Search results for ''current state of AI agent market 2023'': Found 3 relevant
-      articles about the topic including market analysis, competitor data, and industry
-      trends."}, {"role": "assistant", "content": "", "tool_calls": [{"id": "call_ie6tNHSbW9TWIqoXD9CN3MNZ",
-      "type": "function", "function": {"name": "read_website", "arguments": "{\"url\":
-      \"https://example.com/article1\"}"}}, {"id": "call_qxn4V4mMMpOnYSAwVuwarFkB",
-      "type": "function", "function": {"name": "read_website", "arguments": "{\"url\":
-      \"https://example.com/article2\"}"}}, {"id": "call_7ElzUIHHJvuciFWj6eIF5RhF",
-      "type": "function", "function": {"name": "read_website", "arguments": "{\"url\":
-      \"https://example.com/article3\"}"}}]}, {"role": "tool", "tool_call_id": "call_ie6tNHSbW9TWIqoXD9CN3MNZ",
-      "content": "Content from https://example.com/article1: This article discusses
-      key insights about the topic including market size ($50B), growth rate (15%
-      YoY), and major players in the industry."}, {"role": "tool", "tool_call_id":
-      "call_qxn4V4mMMpOnYSAwVuwarFkB", "content": "Content from https://example.com/article2:
-      This article discusses key insights about the topic including market size ($50B),
-      growth rate (15% YoY), and major players in the industry."}, {"role": "tool",
-      "tool_call_id": "call_7ElzUIHHJvuciFWj6eIF5RhF", "content": "Content from https://example.com/article3:
-      This article discusses key insights about the topic including market size ($50B),
-      growth rate (15% YoY), and major players in the industry."}, {"role": "assistant",
-      "content": "", "tool_calls": [{"id": "call_7eE0bJbpvO6YYQNs87iTifQ3", "type":
-      "function", "function": {"name": "generate_report", "arguments": "{\"title\":\"Current
-      State of the AI Agent Market\",\"findings\":\"The AI agent market in 2023 is
-      valued at $50 billion, with a growth rate of 15% YoY. Major players in the market
-      have been identified as contributing to the expansion of industry capabilities.
-      Trends point to increasing adoption across industries such as healthcare and
-      finance, where automation and intelligence are becoming central to operations.
-      Emerging competitive forces are influencing pricing and technological advancements
-      in AI agents. Existing and new entrants focus on innovation to differentiate
-      their offerings and capture market share.\"}"}}]}, {"role": "tool", "tool_call_id":
-      "call_7eE0bJbpvO6YYQNs87iTifQ3", "content": "# Current State of the AI Agent
-      Market\n\n## Executive Summary\nThe AI agent market in 2023 is valued at $50
-      billion, with a growth rate of 15% YoY. Major players in the market have been
-      identified as contributing to the expansion of industry capabilities. Trends
-      point to increasing adoption across industries such as healthcare and finance,
-      where automation and intelligence are becoming central to operations. Emerging
-      competitive forces are influencing pricing and technological advancements in
-      AI agents. Existing and new entrants focus on innovation to differentiate their
-      offerings and capture market share.\n\n## Conclusion\nBased on the analysis,
-      the market shows strong growth potential."}], "stream": false, "stop": ["\nObservation:"],
-      "tool_choice": "auto", "tools": [{"function": {"name": "web_search", "description":
-      "Search the web for information on a given topic.\n\nArgs:\n    query: The search
-      query to look up.\n\nReturns:\n    Search results as a string.", "parameters":
-      {"properties": {"query": {"title": "Query", "type": "string"}}, "required":
-      ["query"], "type": "object", "additionalProperties": false}}, "type": "function"},
-      {"function": {"name": "read_website", "description": "Read and extract content
-      from a website URL.\n\nArgs:\n    url: The URL of the website to read.\n\nReturns:\n    The
-      extracted content from the website.", "parameters": {"properties": {"url": {"title":
-      "Url", "type": "string"}}, "required": ["url"], "type": "object", "additionalProperties":
-      false}}, "type": "function"}, {"function": {"name": "generate_report", "description":
-      "Generate a structured report based on research findings.\n\nArgs:\n    title:
-      The title of the report.\n    findings: The research findings to include.\n\nReturns:\n    A
-      formatted report string.", "parameters": {"properties": {"title": {"title":
-      "Title", "type": "string"}, "findings": {"title": "Findings", "type": "string"}},
-      "required": ["title", "findings"], "type": "object", "additionalProperties":
-      false}}, "type": "function"}]}'
-    headers:
-      Accept:
-      - application/json
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '5276'
-      Content-Type:
-      - application/json
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      api-key:
-      - X-API-KEY-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      x-ms-client-request-id:
-      - X-MS-CLIENT-REQUEST-ID-XXX
-    method: POST
-    uri: https://fake-azure-endpoint.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2024-12-01-preview
-  response:
-    body:
-      string: '{"choices":[{"content_filter_results":{"hate":{"filtered":false,"severity":"safe"},"protected_material_code":{"detected":false,"filtered":false},"protected_material_text":{"detected":false,"filtered":false},"self_harm":{"filtered":false,"severity":"safe"},"sexual":{"filtered":false,"severity":"safe"},"violence":{"filtered":false,"severity":"safe"}},"finish_reason":"stop","index":0,"logprobs":null,"message":{"annotations":[],"content":"The
-        report detailing the current state of the AI agent market has been generated
-        successfully. It highlights the market''s $50 billion valuation in 2023, with
-        a consistent annual growth rate of 15%. Key findings identify the role of
-        major players, impactful trends like sector adoption (healthcare and finance),
-        and the competitive dynamic driving innovation and technological advancements.","refusal":null,"role":"assistant"}}],"created":1770145141,"id":"chatcmpl-D5Fu18JFkDPGsKf10eiS2e2uI04MU","model":"gpt-4o-2024-11-20","object":"chat.completion","prompt_filter_results":[{"prompt_index":0,"content_filter_results":{"hate":{"filtered":false,"severity":"safe"},"jailbreak":{"detected":false,"filtered":false},"self_harm":{"filtered":false,"severity":"safe"},"sexual":{"filtered":false,"severity":"safe"},"violence":{"filtered":false,"severity":"safe"}}}],"system_fingerprint":"fp_b54fe76834","usage":{"completion_tokens":72,"completion_tokens_details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0},"prompt_tokens":787,"prompt_tokens_details":{"audio_tokens":0,"cached_tokens":0},"total_tokens":859}}
-
-        '
-    headers:
-      Content-Length:
-      - '1597'
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 18:59:01 GMT
-      Strict-Transport-Security:
-      - STS-XXX
-      apim-request-id:
-      - APIM-REQUEST-ID-XXX
-      azureml-model-session:
-      - AZUREML-MODEL-SESSION-XXX
-      x-accel-buffering:
-      - 'no'
-      x-content-type-options:
-      - X-CONTENT-TYPE-XXX
-      x-ms-client-request-id:
-      - X-MS-CLIENT-REQUEST-ID-XXX
-      x-ms-deployment-name:
-      - gpt-4o
-      x-ms-rai-invoked:
-      - 'true'
-      x-ms-region:
-      - X-MS-REGION-XXX
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/utilities/TestGeminiStructuredPlanning.test_gemini_research_workflow_generates_steps.yaml

@@ -1,613 +0,0 @@
-interactions:
-- request:
-    body: '{"contents": [{"parts": [{"text": "Create a focused execution plan for
-      the following task:\n\n## Task\nResearch the current state of the AI agent market:\n1.
-      Search for recent information about AI agents and their market trends\n2. Read
-      detailed content from a relevant industry source\n3. Generate a brief report
-      summarizing the key findings\n\nUse the available tools for each step.\n\n##
-      Expected Output\nComplete the task successfully\n\n## Available Tools\nweb_search,
-      read_website, generate_report\n\n## Instructions\nCreate ONLY the essential
-      steps needed to complete this task. Use the MINIMUM number of steps required
-      - do NOT pad your plan with unnecessary steps. Most tasks need only 2-5 steps.\n\nFor
-      each step:\n- State the specific action to take\n- Specify which tool to use
-      (if any)\n- Note dependencies on previous steps if this step requires their
-      output\n- If a step involves multiple items (e.g., research 3 competitors),
-      note this explicitly\n\nDo NOT include:\n- Setup or preparation steps that are
-      obvious\n- Verification steps unless critical\n- Documentation or cleanup steps
-      unless explicitly required\n- Generic steps like \"review results\" or \"finalize
-      output\"\n\nAfter your plan, state:\n- \"READY: I am ready to execute the task.\"
-      if the plan is complete\n- \"NOT READY: I need to refine my plan because [reason].\"
-      if you need more thinking"}], "role": "user"}], "systemInstruction": {"parts":
-      [{"text": "You are a strategic planning assistant. Create minimal, effective
-      execution plans. Prefer fewer steps over more."}], "role": "user"}, "tools":
-      [{"functionDeclarations": [{"description": "Create or refine a reasoning plan
-      for a task with structured steps", "name": "create_reasoning_plan", "parameters_json_schema":
-      {"type": "object", "properties": {"plan": {"type": "string", "description":
-      "A brief summary of the overall plan."}, "steps": {"type": "array", "description":
-      "List of discrete steps to execute the plan", "items": {"type": "object", "properties":
-      {"step_number": {"type": "integer", "description": "Step number (1-based)"},
-      "description": {"type": "string", "description": "What to do in this step"},
-      "tool_to_use": {"type": ["string", "null"], "description": "Tool to use for
-      this step, or null if no tool needed"}, "depends_on": {"type": "array", "items":
-      {"type": "integer"}, "description": "Step numbers this step depends on (empty
-      array if none)"}}, "required": ["step_number", "description", "tool_to_use",
-      "depends_on"], "additionalProperties": false}}, "ready": {"type": "boolean",
-      "description": "Whether the agent is ready to execute the task."}}, "required":
-      ["plan", "steps", "ready"], "additionalProperties": false}}]}], "generationConfig":
-      {"stopSequences": ["\nObservation:"]}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '2747'
-      content-type:
-      - application/json
-      host:
-      - generativelanguage.googleapis.com
-      x-goog-api-client:
-      - google-genai-sdk/1.49.0 gl-python/3.13.3
-      x-goog-api-key:
-      - X-GOOG-API-KEY-XXX
-    method: POST
-    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent
-  response:
-    body:
-      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
-        [\n          {\n            \"functionCall\": {\n              \"name\": \"create_reasoning_plan\",\n
-        \             \"args\": {\n                \"steps\": [\n                  {\n
-        \                   \"step_number\": 1,\n                    \"tool_to_use\":
-        \"web_search\",\n                    \"depends_on\": [],\n                    \"description\":
-        \"Search for recent information on AI agent market trends.\"\n                  },\n
-        \                 {\n                    \"description\": \"Read detailed
-        content from a relevant industry source found in the search results.\",\n
-        \                   \"depends_on\": [\n                      1\n                    ],\n
-        \                   \"step_number\": 2,\n                    \"tool_to_use\":
-        \"read_website\"\n                  },\n                  {\n                    \"depends_on\":
-        [\n                      2\n                    ],\n                    \"step_number\":
-        3,\n                    \"tool_to_use\": \"generate_report\",\n                    \"description\":
-        \"Generate a brief report summarizing the key findings from the researched
-        content.\"\n                  }\n                ],\n                \"plan\":
-        \"Research the current state of the AI agent market and generate a summary
-        report.\",\n                \"ready\": true\n              }\n            },\n
-        \           \"thoughtSignature\": \"CsIIAXLI2nztq0xBScBM9fsnIBhVvD6CWKYYyj3khtIYTNl4oRbOYnH8LQBzET8fRrxiWqnxib7Nn/UVK29pvsHX7TacFxm0ieHb5gmb2lgqo4GpG0P2+HI4xo4vnibPl3OM+bl4M39/JOdBNBmYGUJETnzV++m8INVLIlOuRPGTXRDUOKLNfkyktsJRdNuO68OMu5WXDqrlbuppG1dsK+Y8cyvzDRoMTsYU1arFOZuyLisuhDQ7nTbdXQ8AO0Oc43MdYrSFmfeDBbsnrxDKBMPYtFVadggz4RwKIFvg3Fb9ORho2GkBUum8PNWHZCBXuAoU9FaVdDFVReduuTfZuBwy/Y6MS+8mnLqcQ1wADlg7DnzaOXmALxgfApTEL6YUvwVjVYI1dpCR5ACkFgNq6ecYYumrlZHuHE59p+XOHMhrzu9c99A0mtRvpkz1yu75dMACliSf/2fu4gCPRRLsgez7llp92g7+GzVkbwkRVlMcYQ+0l28sBsfBQd01lQR0vNNbK3JHf/chtCtrRIcgqqnUbTTqm5n8iPHFBWMdEa0L4I1WfPbiUSC9OGwwaoP+Ro6h/gPH9o96gjZQpCft1myrKtgl7dpOaSharMuDfulk2Wd5wJoZ9XR/fxVYQos8sNEIZq8O1cjOW9L74ryKMtw6hF8A4kxGLhOSgXwszNqHoLCLoX6Cz5vb2hZVkCWxq8yn5k3IrTcw/16Jdkx6oNWjHZJmJMz8vl85sUH1ZwZocWHWcUUMo33ZlsBnqPZxwnAj5CW+vQS/xCC7Kq1FciqosYyHgN43bm8JqnHL4qgBAEtDPVrFfaWBpzWWVfXQkX/EVApU/Jr3t9D3gz10CFPsV7d0lx0P7jur8u8Q9n8r2HEi320kNf1EX4YnDioX+nWmHPN203OCOHpDEcEQ89gECMk5M9Xu6EZ94rXmrZJtP5kc0k37fvMexlxIZPuUmV7RpoCTrMVqMyP93eIq9FY/9WsqHVlydumTfEMPI1WY5ObNeHJFhyu2Y6dGB3ONQL1bQ0oboNZujX/AhnauV0A8OS2wsA3yLVk0GFZpTISU+WQ2/Gm7t8CUIgKT3BV4JkYuyNBTONQPLitpfO+TEMcuNZlodinLvkBtBA8B0W55kOAK7y21I9znnNKONo87jg9kfoZMvYlb2DrO9YovQDDhdCZjxXr5VZqbhMH4tb8t5kP/1auCv1GfzV6RVSgyNVYnruqJKEtqgNbLid1FB9EH3Qu0A92HLqdGsuC3qRm2qfyMEmz7iYJ5n/WA5BertGZ/O0SGLEBftgEjQOJhj7flGTEio3yyCHyvw/yGP6S8F3+mPvVLO6/eWMCGm7ig/mG8pjnysRTQTjDv966XhU9SYpinoxTd5mEuWdIHKMZxtBK7qeKY369njKJOP2K220Rk9/Ii+KyzNvbzyobK6oMNcwXgHjO+ssbH+blVUbLai3UblQ==\"\n
-        \         }\n        ],\n        \"role\": \"model\"\n      },\n      \"finishReason\":
-        \"STOP\",\n      \"index\": 0,\n      \"finishMessage\": \"Model generated
-        function call(s).\"\n    }\n  ],\n  \"usageMetadata\": {\n    \"promptTokenCount\":
-        529,\n    \"candidatesTokenCount\": 169,\n    \"totalTokenCount\": 955,\n
-        \   \"promptTokensDetails\": [\n      {\n        \"modality\": \"TEXT\",\n
-        \       \"tokenCount\": 529\n      }\n    ],\n    \"thoughtsTokenCount\":
-        257\n  },\n  \"modelVersion\": \"gemini-2.5-flash\",\n  \"responseId\": \"h0WCacqWA6WM_PUPl-niyQ0\"\n}\n"
-    headers:
-      Alt-Svc:
-      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
-      Content-Type:
-      - application/json; charset=UTF-8
-      Date:
-      - Tue, 03 Feb 2026 18:59:19 GMT
-      Server:
-      - scaffolding on HTTPServer2
-      Server-Timing:
-      - gfet4t7; dur=2345
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Origin
-      - X-Origin
-      - Referer
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      X-Frame-Options:
-      - X-FRAME-OPTIONS-XXX
-      X-XSS-Protection:
-      - '0'
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"contents": [{"parts": [{"text": "\nCurrent Task: Research the current
-      state of the AI agent market:\n1. Search for recent information about AI agents
-      and their market trends\n2. Read detailed content from a relevant industry source\n3.
-      Generate a brief report summarizing the key findings\n\nUse the available tools
-      for each step."}], "role": "user"}], "systemInstruction": {"parts": [{"text":
-      "You are Research Analyst. An experienced analyst skilled at gathering information
-      and synthesizing findings into actionable insights.\nYour personal goal is:
-      Conduct thorough research and produce insightful reports"}], "role": "user"},
-      "tools": [{"functionDeclarations": [{"description": "Search the web for information
-      on a given topic.\n\nArgs:\n    query: The search query to look up.\n\nReturns:\n    Search
-      results as a string.", "name": "web_search", "parameters_json_schema": {"properties":
-      {"query": {"title": "Query", "type": "string"}}, "required": ["query"], "type":
-      "object", "additionalProperties": false}}, {"description": "Read and extract
-      content from a website URL.\n\nArgs:\n    url: The URL of the website to read.\n\nReturns:\n    The
-      extracted content from the website.", "name": "read_website", "parameters_json_schema":
-      {"properties": {"url": {"title": "Url", "type": "string"}}, "required": ["url"],
-      "type": "object", "additionalProperties": false}}, {"description": "Generate
-      a structured report based on research findings.\n\nArgs:\n    title: The title
-      of the report.\n    findings: The research findings to include.\n\nReturns:\n    A
-      formatted report string.", "name": "generate_report", "parameters_json_schema":
-      {"properties": {"title": {"title": "Title", "type": "string"}, "findings": {"title":
-      "Findings", "type": "string"}}, "required": ["title", "findings"], "type": "object",
-      "additionalProperties": false}}]}], "generationConfig": {"stopSequences": ["\nObservation:"]}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1904'
-      content-type:
-      - application/json
-      host:
-      - generativelanguage.googleapis.com
-      x-goog-api-client:
-      - google-genai-sdk/1.49.0 gl-python/3.13.3
-      x-goog-api-key:
-      - X-GOOG-API-KEY-XXX
-    method: POST
-    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent
-  response:
-    body:
-      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
-        [\n          {\n            \"functionCall\": {\n              \"name\": \"web_search\",\n
-        \             \"args\": {\n                \"query\": \"AI agent market trends
-        2023-2024\"\n              }\n            },\n            \"thoughtSignature\":
-        \"CoYEAXLI2nzmyDix3/QA+tMOiUwpDVoA5+RJoRW7kw3okJaVYCa5Usx7eBn4xowP7oXNynS4NfawCYqboufBXjHinq13UTcYg0Y74qIrza4KuctliGmf8G7S4QoS0Y3gqCHQKsxTdShQOg8wirnr8Rdu1eyrrhWE0XKk0HPA0Ssj7zUVoJBqHPqwyvkFyXkMtpcmtq9qXmZYfMFuSKRQnYLVLllL/BpOIL3w7MuofpviO85bvYk9gX0vsDjYWS6EdVEfC9k2BWGjhHaILXT9A1iwNPdDAg33SOC+BlPrGox0ghCr5qEKnBMZhUszqaUCykczFCq+xMIA3xDGNbTjicWb53sL/PXBYLsNty1giW3nKFe8+8eRpUsHUx7oQ82m4AUxKqk99mZjaLp8bHk+rERjFZErcw/pe/3190K0WGHH5ecB4amJCzZtVrQJ1oAZhb7/P1VZ57xmt1z/c1pQgjuvnV+cWE9blh5o6mNNFbFuzJDIO2k8qrFeeDwlCF8OOrxo8F+z1evg4yjZ1+9TLCVFTmZ0S0PI54FS5afb0RdPol2/ISNw7H/dtnO4z6LhT2NmlYqYZr8qfVoUD21rmI08NFs+f/6JW5+7eSQbax76SW+6A2IqqPPyF66MCpqtEzC+hpzVsCBcIQyRQWsdm+RNAs50gmqF6W3CcTPryWkeS7w9ORqxdiU=\"\n
-        \         }\n        ],\n        \"role\": \"model\"\n      },\n      \"finishReason\":
-        \"STOP\",\n      \"index\": 0,\n      \"finishMessage\": \"Model generated
-        function call(s).\"\n    }\n  ],\n  \"usageMetadata\": {\n    \"promptTokenCount\":
-        319,\n    \"candidatesTokenCount\": 28,\n    \"totalTokenCount\": 461,\n    \"promptTokensDetails\":
-        [\n      {\n        \"modality\": \"TEXT\",\n        \"tokenCount\": 319\n
-        \     }\n    ],\n    \"thoughtsTokenCount\": 114\n  },\n  \"modelVersion\":
-        \"gemini-2.5-flash\",\n  \"responseId\": \"iEWCaYyJENDn_uMP4q3N8QE\"\n}\n"
-    headers:
-      Alt-Svc:
-      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
-      Content-Type:
-      - application/json; charset=UTF-8
-      Date:
-      - Tue, 03 Feb 2026 18:59:20 GMT
-      Server:
-      - scaffolding on HTTPServer2
-      Server-Timing:
-      - gfet4t7; dur=1193
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Origin
-      - X-Origin
-      - Referer
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      X-Frame-Options:
-      - X-FRAME-OPTIONS-XXX
-      X-XSS-Protection:
-      - '0'
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"contents": [{"parts": [{"text": "\nCurrent Task: Research the current
-      state of the AI agent market:\n1. Search for recent information about AI agents
-      and their market trends\n2. Read detailed content from a relevant industry source\n3.
-      Generate a brief report summarizing the key findings\n\nUse the available tools
-      for each step."}], "role": "user"}, {"parts": [{"functionCall": {"args": {"query":
-      "AI agent market trends 2023-2024"}, "name": "web_search"}, "thoughtSignature":
-      "CoYEAXLI2nzmyDix3_QA-tMOiUwpDVoA5-RJoRW7kw3okJaVYCa5Usx7eBn4xowP7oXNynS4NfawCYqboufBXjHinq13UTcYg0Y74qIrza4KuctliGmf8G7S4QoS0Y3gqCHQKsxTdShQOg8wirnr8Rdu1eyrrhWE0XKk0HPA0Ssj7zUVoJBqHPqwyvkFyXkMtpcmtq9qXmZYfMFuSKRQnYLVLllL_BpOIL3w7MuofpviO85bvYk9gX0vsDjYWS6EdVEfC9k2BWGjhHaILXT9A1iwNPdDAg33SOC-BlPrGox0ghCr5qEKnBMZhUszqaUCykczFCq-xMIA3xDGNbTjicWb53sL_PXBYLsNty1giW3nKFe8-8eRpUsHUx7oQ82m4AUxKqk99mZjaLp8bHk-rERjFZErcw_pe_3190K0WGHH5ecB4amJCzZtVrQJ1oAZhb7_P1VZ57xmt1z_c1pQgjuvnV-cWE9blh5o6mNNFbFuzJDIO2k8qrFeeDwlCF8OOrxo8F-z1evg4yjZ1-9TLCVFTmZ0S0PI54FS5afb0RdPol2_ISNw7H_dtnO4z6LhT2NmlYqYZr8qfVoUD21rmI08NFs-f_6JW5-7eSQbax76SW-6A2IqqPPyF66MCpqtEzC-hpzVsCBcIQyRQWsdm-RNAs50gmqF6W3CcTPryWkeS7w9ORqxdiU="}],
-      "role": "model"}, {"parts": [{"functionResponse": {"name": "web_search", "response":
-      {"result": "Search results for ''AI agent market trends 2023-2024'': Found 3
-      relevant articles about the topic including market analysis, competitor data,
-      and industry trends."}}}], "role": "user"}], "systemInstruction": {"parts":
-      [{"text": "You are Research Analyst. An experienced analyst skilled at gathering
-      information and synthesizing findings into actionable insights.\nYour personal
-      goal is: Conduct thorough research and produce insightful reports"}], "role":
-      "user"}, "tools": [{"functionDeclarations": [{"description": "Search the web
-      for information on a given topic.\n\nArgs:\n    query: The search query to look
-      up.\n\nReturns:\n    Search results as a string.", "name": "web_search", "parameters_json_schema":
-      {"properties": {"query": {"title": "Query", "type": "string"}}, "required":
-      ["query"], "type": "object", "additionalProperties": false}}, {"description":
-      "Read and extract content from a website URL.\n\nArgs:\n    url: The URL of
-      the website to read.\n\nReturns:\n    The extracted content from the website.",
-      "name": "read_website", "parameters_json_schema": {"properties": {"url": {"title":
-      "Url", "type": "string"}}, "required": ["url"], "type": "object", "additionalProperties":
-      false}}, {"description": "Generate a structured report based on research findings.\n\nArgs:\n    title:
-      The title of the report.\n    findings: The research findings to include.\n\nReturns:\n    A
-      formatted report string.", "name": "generate_report", "parameters_json_schema":
-      {"properties": {"title": {"title": "Title", "type": "string"}, "findings": {"title":
-      "Findings", "type": "string"}}, "required": ["title", "findings"], "type": "object",
-      "additionalProperties": false}}]}], "generationConfig": {"stopSequences": ["\nObservation:"]}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '3015'
-      content-type:
-      - application/json
-      host:
-      - generativelanguage.googleapis.com
-      x-goog-api-client:
-      - google-genai-sdk/1.49.0 gl-python/3.13.3
-      x-goog-api-key:
-      - X-GOOG-API-KEY-XXX
-    method: POST
-    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent
-  response:
-    body:
-      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
-        [\n          {\n            \"functionCall\": {\n              \"name\": \"web_search\",\n
-        \             \"args\": {\n                \"query\": \"latest reports AI
-        agent market analysis\"\n              }\n            },\n            \"thoughtSignature\":
-        \"CpwGAXLI2nybmVGffIN1k+T5M2HmQNlvybZRPoo/ysgNARa+9nrPdRoBZ9RC+Dee9KSk1o7O+IU9l0sWCTirQYcroEhXon+JIQUVTed/L0s//sBOR+hJnZWoaG5ucsfJQvovAQba2Wb7uViEkdySvHfRApF0atewbC+TCKZrxDAQ6Naby8nwUTauJPKlgsBsZVnlViRfIbF7pom1zvXD+d5htjMiuJr1nOuSH0EGQWC4TUiuJD23hgockzhmIpbU/bStn8PFIQNsySEzl6H5sZdlD4auwCMCD2Q+Ur05w1uLv7n8GoSZn5dkdXLR5R7dZ+kkX+xP4w841Ih2gc6rBKT5tSedN01AuJsK65NSfOXZBwakxs58WZXDQXnIQe4d2QThAX3nPdUmhvVI6sHX+ZdtQZIrhE7hRf9j/T/wvvrUao5VDv+mxXd9bcPEV2BzSXkvkAB1SbJ+5wN7Qb2j31lkiUu5uRnZOiVxL5iCS+8Z/jEl4NjpGithbcPoNpFIDOeiE/f8kf7tQJDX+YNquPbYZRJHvIfLalVQndVGNlZVN2jXT3Wwo8So3vmzIDFVjV+pj7tSRNK8hTITm6bfHS+XUZqJdm7eHCzhonyJ7/tl7LbsstPXoZU3ZN50tNpXYOK+NzgzU7iwd9SaHVXgzQRdujWgHuBmSiSd9qNHvdaNwgARVTnMj3VYpehgIuaYMzQmgM99TdC/zmzcqHa5VZSnHKHqMIVc9gjRvVwz4DUm6VLLnKnVYFClM6gofmUI6s9fThiR5EdfimaDTlRlzh6Df33jAbRA9rUTDH6uE+DjiopCvXuHjmQqK9Smyxt2vTao9H7AYIRN7yWmdVoaG0tUSL2XQ31wIW3cEyhz7ihQwFYKJnOkQ3/CiU6KV+4ldk9UY/vKWSgItVTTE6G8Di0iviiCAkmL59Uj7vnIp80+U9rDIK7WhxpAWlrDA6cGQT2LGAXQ2liXtLa31nXyfvCezhtSS8jSVm4SHaiU+INvYtpq2Q7nXPTFbjjZooyC5FePGqAH1T+sRYbR02jaa572/NuwFgBCObTfqO8G5A==\"\n
-        \         }\n        ],\n        \"role\": \"model\"\n      },\n      \"finishReason\":
-        \"STOP\",\n      \"index\": 0,\n      \"finishMessage\": \"Model generated
-        function call(s).\"\n    }\n  ],\n  \"usageMetadata\": {\n    \"promptTokenCount\":
-        400,\n    \"candidatesTokenCount\": 20,\n    \"totalTokenCount\": 589,\n    \"promptTokensDetails\":
-        [\n      {\n        \"modality\": \"TEXT\",\n        \"tokenCount\": 400\n
-        \     }\n    ],\n    \"thoughtsTokenCount\": 169\n  },\n  \"modelVersion\":
-        \"gemini-2.5-flash\",\n  \"responseId\": \"ikWCacqBG8ve_uMPj4KFyAY\"\n}\n"
-    headers:
-      Alt-Svc:
-      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
-      Content-Type:
-      - application/json; charset=UTF-8
-      Date:
-      - Tue, 03 Feb 2026 18:59:22 GMT
-      Server:
-      - scaffolding on HTTPServer2
-      Server-Timing:
-      - gfet4t7; dur=2125
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Origin
-      - X-Origin
-      - Referer
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      X-Frame-Options:
-      - X-FRAME-OPTIONS-XXX
-      X-XSS-Protection:
-      - '0'
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"contents": [{"parts": [{"text": "\nCurrent Task: Research the current
-      state of the AI agent market:\n1. Search for recent information about AI agents
-      and their market trends\n2. Read detailed content from a relevant industry source\n3.
-      Generate a brief report summarizing the key findings\n\nUse the available tools
-      for each step."}], "role": "user"}, {"parts": [{"functionCall": {"args": {"query":
-      "AI agent market trends 2023-2024"}, "name": "web_search"}, "thoughtSignature":
-      "CoYEAXLI2nzmyDix3_QA-tMOiUwpDVoA5-RJoRW7kw3okJaVYCa5Usx7eBn4xowP7oXNynS4NfawCYqboufBXjHinq13UTcYg0Y74qIrza4KuctliGmf8G7S4QoS0Y3gqCHQKsxTdShQOg8wirnr8Rdu1eyrrhWE0XKk0HPA0Ssj7zUVoJBqHPqwyvkFyXkMtpcmtq9qXmZYfMFuSKRQnYLVLllL_BpOIL3w7MuofpviO85bvYk9gX0vsDjYWS6EdVEfC9k2BWGjhHaILXT9A1iwNPdDAg33SOC-BlPrGox0ghCr5qEKnBMZhUszqaUCykczFCq-xMIA3xDGNbTjicWb53sL_PXBYLsNty1giW3nKFe8-8eRpUsHUx7oQ82m4AUxKqk99mZjaLp8bHk-rERjFZErcw_pe_3190K0WGHH5ecB4amJCzZtVrQJ1oAZhb7_P1VZ57xmt1z_c1pQgjuvnV-cWE9blh5o6mNNFbFuzJDIO2k8qrFeeDwlCF8OOrxo8F-z1evg4yjZ1-9TLCVFTmZ0S0PI54FS5afb0RdPol2_ISNw7H_dtnO4z6LhT2NmlYqYZr8qfVoUD21rmI08NFs-f_6JW5-7eSQbax76SW-6A2IqqPPyF66MCpqtEzC-hpzVsCBcIQyRQWsdm-RNAs50gmqF6W3CcTPryWkeS7w9ORqxdiU="}],
-      "role": "model"}, {"parts": [{"functionResponse": {"name": "web_search", "response":
-      {"result": "Search results for ''AI agent market trends 2023-2024'': Found 3
-      relevant articles about the topic including market analysis, competitor data,
-      and industry trends."}}}], "role": "user"}, {"parts": [{"functionCall": {"args":
-      {"query": "latest reports AI agent market analysis"}, "name": "web_search"},
-      "thoughtSignature": "CpwGAXLI2nybmVGffIN1k-T5M2HmQNlvybZRPoo_ysgNARa-9nrPdRoBZ9RC-Dee9KSk1o7O-IU9l0sWCTirQYcroEhXon-JIQUVTed_L0s__sBOR-hJnZWoaG5ucsfJQvovAQba2Wb7uViEkdySvHfRApF0atewbC-TCKZrxDAQ6Naby8nwUTauJPKlgsBsZVnlViRfIbF7pom1zvXD-d5htjMiuJr1nOuSH0EGQWC4TUiuJD23hgockzhmIpbU_bStn8PFIQNsySEzl6H5sZdlD4auwCMCD2Q-Ur05w1uLv7n8GoSZn5dkdXLR5R7dZ-kkX-xP4w841Ih2gc6rBKT5tSedN01AuJsK65NSfOXZBwakxs58WZXDQXnIQe4d2QThAX3nPdUmhvVI6sHX-ZdtQZIrhE7hRf9j_T_wvvrUao5VDv-mxXd9bcPEV2BzSXkvkAB1SbJ-5wN7Qb2j31lkiUu5uRnZOiVxL5iCS-8Z_jEl4NjpGithbcPoNpFIDOeiE_f8kf7tQJDX-YNquPbYZRJHvIfLalVQndVGNlZVN2jXT3Wwo8So3vmzIDFVjV-pj7tSRNK8hTITm6bfHS-XUZqJdm7eHCzhonyJ7_tl7LbsstPXoZU3ZN50tNpXYOK-NzgzU7iwd9SaHVXgzQRdujWgHuBmSiSd9qNHvdaNwgARVTnMj3VYpehgIuaYMzQmgM99TdC_zmzcqHa5VZSnHKHqMIVc9gjRvVwz4DUm6VLLnKnVYFClM6gofmUI6s9fThiR5EdfimaDTlRlzh6Df33jAbRA9rUTDH6uE-DjiopCvXuHjmQqK9Smyxt2vTao9H7AYIRN7yWmdVoaG0tUSL2XQ31wIW3cEyhz7ihQwFYKJnOkQ3_CiU6KV-4ldk9UY_vKWSgItVTTE6G8Di0iviiCAkmL59Uj7vnIp80-U9rDIK7WhxpAWlrDA6cGQT2LGAXQ2liXtLa31nXyfvCezhtSS8jSVm4SHaiU-INvYtpq2Q7nXPTFbjjZooyC5FePGqAH1T-sRYbR02jaa572_NuwFgBCObTfqO8G5A=="}],
-      "role": "model"}, {"parts": [{"functionResponse": {"name": "web_search", "response":
-      {"result": "Search results for ''latest reports AI agent market analysis'':
-      Found 3 relevant articles about the topic including market analysis, competitor
-      data, and industry trends."}}}], "role": "user"}], "systemInstruction": {"parts":
-      [{"text": "You are Research Analyst. An experienced analyst skilled at gathering
-      information and synthesizing findings into actionable insights.\nYour personal
-      goal is: Conduct thorough research and produce insightful reports"}], "role":
-      "user"}, "tools": [{"functionDeclarations": [{"description": "Search the web
-      for information on a given topic.\n\nArgs:\n    query: The search query to look
-      up.\n\nReturns:\n    Search results as a string.", "name": "web_search", "parameters_json_schema":
-      {"properties": {"query": {"title": "Query", "type": "string"}}, "required":
-      ["query"], "type": "object", "additionalProperties": false}}, {"description":
-      "Read and extract content from a website URL.\n\nArgs:\n    url: The URL of
-      the website to read.\n\nReturns:\n    The extracted content from the website.",
-      "name": "read_website", "parameters_json_schema": {"properties": {"url": {"title":
-      "Url", "type": "string"}}, "required": ["url"], "type": "object", "additionalProperties":
-      false}}, {"description": "Generate a structured report based on research findings.\n\nArgs:\n    title:
-      The title of the report.\n    findings: The research findings to include.\n\nReturns:\n    A
-      formatted report string.", "name": "generate_report", "parameters_json_schema":
-      {"properties": {"title": {"title": "Title", "type": "string"}, "findings": {"title":
-      "Findings", "type": "string"}}, "required": ["title", "findings"], "type": "object",
-      "additionalProperties": false}}]}], "generationConfig": {"stopSequences": ["\nObservation:"]}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '4512'
-      content-type:
-      - application/json
-      host:
-      - generativelanguage.googleapis.com
-      x-goog-api-client:
-      - google-genai-sdk/1.49.0 gl-python/3.13.3
-      x-goog-api-key:
-      - X-GOOG-API-KEY-XXX
-    method: POST
-    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent
-  response:
-    body:
-      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
-        [\n          {\n            \"functionCall\": {\n              \"name\": \"read_website\",\n
-        \             \"args\": {\n                \"url\": \"https://www.example.com/ai-agent-market-report\"\n
-        \             }\n            },\n            \"thoughtSignature\": \"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\"\n
-        \         }\n        ],\n        \"role\": \"model\"\n      },\n      \"finishReason\":
-        \"STOP\",\n      \"index\": 0,\n      \"finishMessage\": \"Model generated
-        function call(s).\"\n    }\n  ],\n  \"usageMetadata\": {\n    \"promptTokenCount\":
-        465,\n    \"candidatesTokenCount\": 29,\n    \"totalTokenCount\": 916,\n    \"promptTokensDetails\":
-        [\n      {\n        \"modality\": \"TEXT\",\n        \"tokenCount\": 465\n
-        \     }\n    ],\n    \"thoughtsTokenCount\": 422\n  },\n  \"modelVersion\":
-        \"gemini-2.5-flash\",\n  \"responseId\": \"jUWCadDOIdi8_uMPxuOu4Ak\"\n}\n"
-    headers:
-      Alt-Svc:
-      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
-      Content-Type:
-      - application/json; charset=UTF-8
-      Date:
-      - Tue, 03 Feb 2026 18:59:25 GMT
-      Server:
-      - scaffolding on HTTPServer2
-      Server-Timing:
-      - gfet4t7; dur=3079
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Origin
-      - X-Origin
-      - Referer
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      X-Frame-Options:
-      - X-FRAME-OPTIONS-XXX
-      X-XSS-Protection:
-      - '0'
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"contents": [{"parts": [{"text": "\nCurrent Task: Research the current
-      state of the AI agent market:\n1. Search for recent information about AI agents
-      and their market trends\n2. Read detailed content from a relevant industry source\n3.
-      Generate a brief report summarizing the key findings\n\nUse the available tools
-      for each step."}], "role": "user"}, {"parts": [{"functionCall": {"args": {"query":
-      "AI agent market trends 2023-2024"}, "name": "web_search"}, "thoughtSignature":
-      "CoYEAXLI2nzmyDix3_QA-tMOiUwpDVoA5-RJoRW7kw3okJaVYCa5Usx7eBn4xowP7oXNynS4NfawCYqboufBXjHinq13UTcYg0Y74qIrza4KuctliGmf8G7S4QoS0Y3gqCHQKsxTdShQOg8wirnr8Rdu1eyrrhWE0XKk0HPA0Ssj7zUVoJBqHPqwyvkFyXkMtpcmtq9qXmZYfMFuSKRQnYLVLllL_BpOIL3w7MuofpviO85bvYk9gX0vsDjYWS6EdVEfC9k2BWGjhHaILXT9A1iwNPdDAg33SOC-BlPrGox0ghCr5qEKnBMZhUszqaUCykczFCq-xMIA3xDGNbTjicWb53sL_PXBYLsNty1giW3nKFe8-8eRpUsHUx7oQ82m4AUxKqk99mZjaLp8bHk-rERjFZErcw_pe_3190K0WGHH5ecB4amJCzZtVrQJ1oAZhb7_P1VZ57xmt1z_c1pQgjuvnV-cWE9blh5o6mNNFbFuzJDIO2k8qrFeeDwlCF8OOrxo8F-z1evg4yjZ1-9TLCVFTmZ0S0PI54FS5afb0RdPol2_ISNw7H_dtnO4z6LhT2NmlYqYZr8qfVoUD21rmI08NFs-f_6JW5-7eSQbax76SW-6A2IqqPPyF66MCpqtEzC-hpzVsCBcIQyRQWsdm-RNAs50gmqF6W3CcTPryWkeS7w9ORqxdiU="}],
-      "role": "model"}, {"parts": [{"functionResponse": {"name": "web_search", "response":
-      {"result": "Search results for ''AI agent market trends 2023-2024'': Found 3
-      relevant articles about the topic including market analysis, competitor data,
-      and industry trends."}}}], "role": "user"}, {"parts": [{"functionCall": {"args":
-      {"query": "latest reports AI agent market analysis"}, "name": "web_search"},
-      "thoughtSignature": "CpwGAXLI2nybmVGffIN1k-T5M2HmQNlvybZRPoo_ysgNARa-9nrPdRoBZ9RC-Dee9KSk1o7O-IU9l0sWCTirQYcroEhXon-JIQUVTed_L0s__sBOR-hJnZWoaG5ucsfJQvovAQba2Wb7uViEkdySvHfRApF0atewbC-TCKZrxDAQ6Naby8nwUTauJPKlgsBsZVnlViRfIbF7pom1zvXD-d5htjMiuJr1nOuSH0EGQWC4TUiuJD23hgockzhmIpbU_bStn8PFIQNsySEzl6H5sZdlD4auwCMCD2Q-Ur05w1uLv7n8GoSZn5dkdXLR5R7dZ-kkX-xP4w841Ih2gc6rBKT5tSedN01AuJsK65NSfOXZBwakxs58WZXDQXnIQe4d2QThAX3nPdUmhvVI6sHX-ZdtQZIrhE7hRf9j_T_wvvrUao5VDv-mxXd9bcPEV2BzSXkvkAB1SbJ-5wN7Qb2j31lkiUu5uRnZOiVxL5iCS-8Z_jEl4NjpGithbcPoNpFIDOeiE_f8kf7tQJDX-YNquPbYZRJHvIfLalVQndVGNlZVN2jXT3Wwo8So3vmzIDFVjV-pj7tSRNK8hTITm6bfHS-XUZqJdm7eHCzhonyJ7_tl7LbsstPXoZU3ZN50tNpXYOK-NzgzU7iwd9SaHVXgzQRdujWgHuBmSiSd9qNHvdaNwgARVTnMj3VYpehgIuaYMzQmgM99TdC_zmzcqHa5VZSnHKHqMIVc9gjRvVwz4DUm6VLLnKnVYFClM6gofmUI6s9fThiR5EdfimaDTlRlzh6Df33jAbRA9rUTDH6uE-DjiopCvXuHjmQqK9Smyxt2vTao9H7AYIRN7yWmdVoaG0tUSL2XQ31wIW3cEyhz7ihQwFYKJnOkQ3_CiU6KV-4ldk9UY_vKWSgItVTTE6G8Di0iviiCAkmL59Uj7vnIp80-U9rDIK7WhxpAWlrDA6cGQT2LGAXQ2liXtLa31nXyfvCezhtSS8jSVm4SHaiU-INvYtpq2Q7nXPTFbjjZooyC5FePGqAH1T-sRYbR02jaa572_NuwFgBCObTfqO8G5A=="}],
-      "role": "model"}, {"parts": [{"functionResponse": {"name": "web_search", "response":
-      {"result": "Search results for ''latest reports AI agent market analysis'':
-      Found 3 relevant articles about the topic including market analysis, competitor
-      data, and industry trends."}}}], "role": "user"}, {"parts": [{"functionCall":
-      {"args": {"url": "https://www.example.com/ai-agent-market-report"}, "name":
-      "read_website"}, "thoughtSignature": "CooPAXLI2nzYy6ki8YJo4RDDzryK6qtkbIEWXCh0ZjpoRX2fgNghUrxXZUwrsrbrwEpccdvWCDpb5ZkwYMNuzMi4yRUsjfcebfd2VCwQgvWnWmitj3taAcLCUDIJX5pGt0L2O8V6ehWmrANQHGw6Qc_QVx5dMlSFeFKHtfc1M95CJz2BxZd3lnuKLCEu7LCCiqIDdd1o1y_EcGsl7OHai6WyQJg49Cvcww__Z-kfSVoAPGNedTYPIf4ImttMyofV8-yczI0IGjhFzE0Qk1Pvo84O9NyOufpPELeKY8l1yfZgSZEL0sUA6weqf1P_xzNKt6h96Rh1KpAx5iTGFtqOWJrJ8OP-ZdGJ-rA-xZQuTRtKbW_e60rC5kPgJnkhWCp1p7HTLgTGwpzzxztqL0ggURaWw8GJw8S41BcM5mFEA-a7ivMWPMLdMk6h5gr_Y8JTnLSRZFoZYHkY9bTcAFPc9gapyFlKkQDciYet_MHe2zfE7ycx0e8c0W7ISoYPHpXW_WxNekMiNdfx1eg_mEX_Y0Vjc70p-HtbnEGaBoZWJSo-cJtZdA4sNJaIuEnnVTtAdAtnoxJUOyr2jrKDAsSjHmVoeLARZO2_DuJKsEVNHzsNPMw4SrBq1DkG52Aof7KcskOfW2OyoZEUnIf23IRabKflUG_7dHGqYfLtkWRApWZYBy2eQILwsmXJ4xx27S7_02Jl0D8rX3vOQhjS7lTjrXvy8wU3biUFvbnqJuLj3ACLn7Hn1axe4dB7zIpYC1di63DDs1fQp79d2VaGRC-tVMKiQu_-yC6nCM4j8JSnpBNgvyhq3ilAr_iDHD6GkbxdBBChFbZl0KY-WkrcZpPp2g2m_beiQuzF-cM6RuaqF2W0TEjVT-OZ1ivObreXFVFWa9T5qFsTjV3E_SFlmrXdx6Kf8d0i9QeEwbzBIvvX3VNUdW1DJ95WylaUXFtljk_cqylri2j2WTPMTSV9fcM_a8UWoayUAuLzq8zgxd2Wvrm8uvGcaewAQT-yK-u5FsLFoKxaMkoakb2_1tjWfhn-MrbIoYOBIebUapUhADUJgGDTG7byEEQlbwNaa8rOZ5ZpdBrDXjtj1tsz6cqaEiCbtZWqei0myuMa0J6Z3FHoceSUgOACD_bHWSkzdW7LdKBKLxB25fKfD1hCLscE1skZ7nAEZWmrUzKz9yCiqAPfatQhHqnr3EchEB_dxbNXxCCT6IFxemhb9AsaQWjcTrlQJiuz8t4VMmu1slgEcrhweZ_PpxI_E74qvV9ljcFLcziW0BZaqepJMeBe2cLfVVki5R5kudQVuAcCEdkrwBDWAwZlO9aWTmiZ9-ggfl3F_63JzZXSM_NDc_2rJ1k65e-O-vyTzkrUwnSPnh4RPK6jeIul4SSLPgyZBwp0qHyTl4As8jpMe9Rbt0NRli6Z5eAr_IYdbicKo_pzqiupdxvu4u-jKt-F4KojU9avgWFAB01isHHO5Z1vzVJ6XDilWeah5DvHc1lkcPCXtbBGvykfFqJIBhthnFi0f_S4HV-IlOKwvKbfmL5GplD7H-DjUA5UdHjw8HoJa6uQxhbERy5dZlYqxN918aL147Afq4LuPoWUJULEsYULwUuA6HspemIKUltHacOAxZgP4OLVkB3zwssj8E6rMtU1puupHiL7J66fFaR3co71gzzlvl8R2Xi3xEQdpigxxCUAsZWMrSrITRBnKPKGF1CrFEhU6FP6bQAQ6UuhAdqLoJihwVnMTyY9fGUriwCkrQu5gK7ZQlnXyluV0J_5xWh4sOaPmwmeiUXMBPN0iGb7z24lyHaI3QXz3kGlJBnIFhseJTJo3ed66Z_LAf8I_hFC6s_sIioEmRgd4tm3Q1U05ETKrptnzo8Ac4AOTdJtbQv0uDQSkoefUbebu7x6L9Dns04VSvDPKLwlFQd81sl9DYmi9SPDxKT7S6gfG6WjJ9z35eNSR01QW1QIgAAhMU8UX4o7QQaXnUZxfZeYRMXlzu_xb4KSREvc_FeLJ-IvnPFgzryAgLi_Sipl__Eul0sjrREPYJE1GxBOIoURGa-Bsmc3yy8aWArxv_HGpbLzwjmH8TaMvB3P_4tkvT-5IjJlpe0UrR1ssqasUtwfH9yWv5-4i-EdJrJ_SJ4Hl1Vlj9zi9lEFr33Zs96kn8ZOkBHp0m7Sxr5xP-krSxQkROIpu0d02kIqQ3nob-kGbnAf0zkmH6pS3H4mG2Zksu8KcGvghx7XTl3qBOJ-ZY4vlev2cSMBfMmnbUHKvMlz4YsmTGR1JPntDguA8UJJ1UZCex4E_W3KcHwd4qvzqgMZNjdarIvGjlmnKmoL1RV7EqUsBkpk-jauY0SqoWsIIf4b6O9Y3fQRRJURLeIfGCTmlxl-df-4yjqUhxUXTaQsX2KlEJ3tZK-ZI9FdKMzqPip2oMFwf2XfLIyIuRA0NU5fDRIxqPUzYv6RQ-zhXXB1QscsAtyf1t-LsaVw__1Vfj6V3Ups4pNyiwMAZg1z9DaIHht--VfgCdqT4RLcaGI8eEDrjkOc9G_iLkLBCfOB7EZkcXT20Lc1Silxa--dZsaYp5Tni8dz6f5YWg=="}],
-      "role": "model"}, {"parts": [{"functionResponse": {"name": "read_website", "response":
-      {"result": "Content from https://www.example.com/ai-agent-market-report: This
-      article discusses key insights about the topic including market size ($50B),
-      growth rate (15% YoY), and major players in the industry."}}}], "role": "user"}],
-      "systemInstruction": {"parts": [{"text": "You are Research Analyst. An experienced
-      analyst skilled at gathering information and synthesizing findings into actionable
-      insights.\nYour personal goal is: Conduct thorough research and produce insightful
-      reports"}], "role": "user"}, "tools": [{"functionDeclarations": [{"description":
-      "Search the web for information on a given topic.\n\nArgs:\n    query: The search
-      query to look up.\n\nReturns:\n    Search results as a string.", "name": "web_search",
-      "parameters_json_schema": {"properties": {"query": {"title": "Query", "type":
-      "string"}}, "required": ["query"], "type": "object", "additionalProperties":
-      false}}, {"description": "Read and extract content from a website URL.\n\nArgs:\n    url:
-      The URL of the website to read.\n\nReturns:\n    The extracted content from
-      the website.", "name": "read_website", "parameters_json_schema": {"properties":
-      {"url": {"title": "Url", "type": "string"}}, "required": ["url"], "type": "object",
-      "additionalProperties": false}}, {"description": "Generate a structured report
-      based on research findings.\n\nArgs:\n    title: The title of the report.\n    findings:
-      The research findings to include.\n\nReturns:\n    A formatted report string.",
-      "name": "generate_report", "parameters_json_schema": {"properties": {"title":
-      {"title": "Title", "type": "string"}, "findings": {"title": "Findings", "type":
-      "string"}}, "required": ["title", "findings"], "type": "object", "additionalProperties":
-      false}}]}], "generationConfig": {"stopSequences": ["\nObservation:"]}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '7562'
-      content-type:
-      - application/json
-      host:
-      - generativelanguage.googleapis.com
-      x-goog-api-client:
-      - google-genai-sdk/1.49.0 gl-python/3.13.3
-      x-goog-api-key:
-      - X-GOOG-API-KEY-XXX
-    method: POST
-    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent
-  response:
-    body:
-      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
-        [\n          {\n            \"functionCall\": {\n              \"name\": \"generate_report\",\n
-        \             \"args\": {\n                \"findings\": \"The AI agent market
-        is currently valued at $50 billion and is experiencing a strong growth rate
-        of 15% year-over-year. Key players in the industry are contributing to this
-        expansion, driven by increasing adoption across various sectors.\",\n                \"title\":
-        \"Current State of the AI Agent Market\"\n              }\n            },\n
-        \           \"thoughtSignature\": \"CuACAXLI2nzhub94iTgphfrBnaQV13Wv0+kRJj+l9jEDfxsyNg9eGnhxRfj4cued3Mgvv1CR9vkpfDV/V9x57TVWLNwPsVvsTgZKI0pwmV355sUCRKqAyfRBwDWhn0UAl9+sYNFCKUJCp8G5QBGfrar1lYLltX/z83d4O13Wn5Ugvxco9o4CdxnnPJOWkTPETRgXA/1HSdEiwGNqt0A3lKYkGRXQx+XyK54lDwmOBg+Yx4ZVgUxANXLK1z91NF/6cpmSVgoE2sL0VrIHISYs4XdUCj1fL3R7DpnZdrrZhmqnTjEgkeR1C3BR5GJeSUmg+kmqjPSPnP0NYiZo9H9SGL/ewGz3wg+GKcILAa4nD7/tfdqIMbAff8PJemwJE4ONT5zAmJ69/NFj0i1X01v04E8f2NdHewPSsKO5mptk5qzWxoW3G3uUhXccxk62EydTsESf6WRwolsmphaGgVE9AwuhzQ==\"\n
-        \         }\n        ],\n        \"role\": \"model\"\n      },\n      \"finishReason\":
-        \"STOP\",\n      \"index\": 0,\n      \"finishMessage\": \"Model generated
-        function call(s).\"\n    }\n  ],\n  \"usageMetadata\": {\n    \"promptTokenCount\":
-        557,\n    \"candidatesTokenCount\": 73,\n    \"totalTokenCount\": 700,\n    \"cachedContentTokenCount\":
-        330,\n    \"promptTokensDetails\": [\n      {\n        \"modality\": \"TEXT\",\n
-        \       \"tokenCount\": 557\n      }\n    ],\n    \"cacheTokensDetails\":
-        [\n      {\n        \"modality\": \"TEXT\",\n        \"tokenCount\": 330\n
-        \     }\n    ],\n    \"thoughtsTokenCount\": 70\n  },\n  \"modelVersion\":
-        \"gemini-2.5-flash\",\n  \"responseId\": \"jkWCacGZMLrv_uMPibCHmQU\"\n}\n"
-    headers:
-      Alt-Svc:
-      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
-      Content-Type:
-      - application/json; charset=UTF-8
-      Date:
-      - Tue, 03 Feb 2026 18:59:26 GMT
-      Server:
-      - scaffolding on HTTPServer2
-      Server-Timing:
-      - gfet4t7; dur=1224
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Origin
-      - X-Origin
-      - Referer
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      X-Frame-Options:
-      - X-FRAME-OPTIONS-XXX
-      X-XSS-Protection:
-      - '0'
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"contents": [{"parts": [{"text": "\nCurrent Task: Research the current
-      state of the AI agent market:\n1. Search for recent information about AI agents
-      and their market trends\n2. Read detailed content from a relevant industry source\n3.
-      Generate a brief report summarizing the key findings\n\nUse the available tools
-      for each step."}], "role": "user"}, {"parts": [{"functionCall": {"args": {"query":
-      "AI agent market trends 2023-2024"}, "name": "web_search"}, "thoughtSignature":
-      "CoYEAXLI2nzmyDix3_QA-tMOiUwpDVoA5-RJoRW7kw3okJaVYCa5Usx7eBn4xowP7oXNynS4NfawCYqboufBXjHinq13UTcYg0Y74qIrza4KuctliGmf8G7S4QoS0Y3gqCHQKsxTdShQOg8wirnr8Rdu1eyrrhWE0XKk0HPA0Ssj7zUVoJBqHPqwyvkFyXkMtpcmtq9qXmZYfMFuSKRQnYLVLllL_BpOIL3w7MuofpviO85bvYk9gX0vsDjYWS6EdVEfC9k2BWGjhHaILXT9A1iwNPdDAg33SOC-BlPrGox0ghCr5qEKnBMZhUszqaUCykczFCq-xMIA3xDGNbTjicWb53sL_PXBYLsNty1giW3nKFe8-8eRpUsHUx7oQ82m4AUxKqk99mZjaLp8bHk-rERjFZErcw_pe_3190K0WGHH5ecB4amJCzZtVrQJ1oAZhb7_P1VZ57xmt1z_c1pQgjuvnV-cWE9blh5o6mNNFbFuzJDIO2k8qrFeeDwlCF8OOrxo8F-z1evg4yjZ1-9TLCVFTmZ0S0PI54FS5afb0RdPol2_ISNw7H_dtnO4z6LhT2NmlYqYZr8qfVoUD21rmI08NFs-f_6JW5-7eSQbax76SW-6A2IqqPPyF66MCpqtEzC-hpzVsCBcIQyRQWsdm-RNAs50gmqF6W3CcTPryWkeS7w9ORqxdiU="}],
-      "role": "model"}, {"parts": [{"functionResponse": {"name": "web_search", "response":
-      {"result": "Search results for ''AI agent market trends 2023-2024'': Found 3
-      relevant articles about the topic including market analysis, competitor data,
-      and industry trends."}}}], "role": "user"}, {"parts": [{"functionCall": {"args":
-      {"query": "latest reports AI agent market analysis"}, "name": "web_search"},
-      "thoughtSignature": "CpwGAXLI2nybmVGffIN1k-T5M2HmQNlvybZRPoo_ysgNARa-9nrPdRoBZ9RC-Dee9KSk1o7O-IU9l0sWCTirQYcroEhXon-JIQUVTed_L0s__sBOR-hJnZWoaG5ucsfJQvovAQba2Wb7uViEkdySvHfRApF0atewbC-TCKZrxDAQ6Naby8nwUTauJPKlgsBsZVnlViRfIbF7pom1zvXD-d5htjMiuJr1nOuSH0EGQWC4TUiuJD23hgockzhmIpbU_bStn8PFIQNsySEzl6H5sZdlD4auwCMCD2Q-Ur05w1uLv7n8GoSZn5dkdXLR5R7dZ-kkX-xP4w841Ih2gc6rBKT5tSedN01AuJsK65NSfOXZBwakxs58WZXDQXnIQe4d2QThAX3nPdUmhvVI6sHX-ZdtQZIrhE7hRf9j_T_wvvrUao5VDv-mxXd9bcPEV2BzSXkvkAB1SbJ-5wN7Qb2j31lkiUu5uRnZOiVxL5iCS-8Z_jEl4NjpGithbcPoNpFIDOeiE_f8kf7tQJDX-YNquPbYZRJHvIfLalVQndVGNlZVN2jXT3Wwo8So3vmzIDFVjV-pj7tSRNK8hTITm6bfHS-XUZqJdm7eHCzhonyJ7_tl7LbsstPXoZU3ZN50tNpXYOK-NzgzU7iwd9SaHVXgzQRdujWgHuBmSiSd9qNHvdaNwgARVTnMj3VYpehgIuaYMzQmgM99TdC_zmzcqHa5VZSnHKHqMIVc9gjRvVwz4DUm6VLLnKnVYFClM6gofmUI6s9fThiR5EdfimaDTlRlzh6Df33jAbRA9rUTDH6uE-DjiopCvXuHjmQqK9Smyxt2vTao9H7AYIRN7yWmdVoaG0tUSL2XQ31wIW3cEyhz7ihQwFYKJnOkQ3_CiU6KV-4ldk9UY_vKWSgItVTTE6G8Di0iviiCAkmL59Uj7vnIp80-U9rDIK7WhxpAWlrDA6cGQT2LGAXQ2liXtLa31nXyfvCezhtSS8jSVm4SHaiU-INvYtpq2Q7nXPTFbjjZooyC5FePGqAH1T-sRYbR02jaa572_NuwFgBCObTfqO8G5A=="}],
-      "role": "model"}, {"parts": [{"functionResponse": {"name": "web_search", "response":
-      {"result": "Search results for ''latest reports AI agent market analysis'':
-      Found 3 relevant articles about the topic including market analysis, competitor
-      data, and industry trends."}}}], "role": "user"}, {"parts": [{"functionCall":
-      {"args": {"url": "https://www.example.com/ai-agent-market-report"}, "name":
-      "read_website"}, "thoughtSignature": "CooPAXLI2nzYy6ki8YJo4RDDzryK6qtkbIEWXCh0ZjpoRX2fgNghUrxXZUwrsrbrwEpccdvWCDpb5ZkwYMNuzMi4yRUsjfcebfd2VCwQgvWnWmitj3taAcLCUDIJX5pGt0L2O8V6ehWmrANQHGw6Qc_QVx5dMlSFeFKHtfc1M95CJz2BxZd3lnuKLCEu7LCCiqIDdd1o1y_EcGsl7OHai6WyQJg49Cvcww__Z-kfSVoAPGNedTYPIf4ImttMyofV8-yczI0IGjhFzE0Qk1Pvo84O9NyOufpPELeKY8l1yfZgSZEL0sUA6weqf1P_xzNKt6h96Rh1KpAx5iTGFtqOWJrJ8OP-ZdGJ-rA-xZQuTRtKbW_e60rC5kPgJnkhWCp1p7HTLgTGwpzzxztqL0ggURaWw8GJw8S41BcM5mFEA-a7ivMWPMLdMk6h5gr_Y8JTnLSRZFoZYHkY9bTcAFPc9gapyFlKkQDciYet_MHe2zfE7ycx0e8c0W7ISoYPHpXW_WxNekMiNdfx1eg_mEX_Y0Vjc70p-HtbnEGaBoZWJSo-cJtZdA4sNJaIuEnnVTtAdAtnoxJUOyr2jrKDAsSjHmVoeLARZO2_DuJKsEVNHzsNPMw4SrBq1DkG52Aof7KcskOfW2OyoZEUnIf23IRabKflUG_7dHGqYfLtkWRApWZYBy2eQILwsmXJ4xx27S7_02Jl0D8rX3vOQhjS7lTjrXvy8wU3biUFvbnqJuLj3ACLn7Hn1axe4dB7zIpYC1di63DDs1fQp79d2VaGRC-tVMKiQu_-yC6nCM4j8JSnpBNgvyhq3ilAr_iDHD6GkbxdBBChFbZl0KY-WkrcZpPp2g2m_beiQuzF-cM6RuaqF2W0TEjVT-OZ1ivObreXFVFWa9T5qFsTjV3E_SFlmrXdx6Kf8d0i9QeEwbzBIvvX3VNUdW1DJ95WylaUXFtljk_cqylri2j2WTPMTSV9fcM_a8UWoayUAuLzq8zgxd2Wvrm8uvGcaewAQT-yK-u5FsLFoKxaMkoakb2_1tjWfhn-MrbIoYOBIebUapUhADUJgGDTG7byEEQlbwNaa8rOZ5ZpdBrDXjtj1tsz6cqaEiCbtZWqei0myuMa0J6Z3FHoceSUgOACD_bHWSkzdW7LdKBKLxB25fKfD1hCLscE1skZ7nAEZWmrUzKz9yCiqAPfatQhHqnr3EchEB_dxbNXxCCT6IFxemhb9AsaQWjcTrlQJiuz8t4VMmu1slgEcrhweZ_PpxI_E74qvV9ljcFLcziW0BZaqepJMeBe2cLfVVki5R5kudQVuAcCEdkrwBDWAwZlO9aWTmiZ9-ggfl3F_63JzZXSM_NDc_2rJ1k65e-O-vyTzkrUwnSPnh4RPK6jeIul4SSLPgyZBwp0qHyTl4As8jpMe9Rbt0NRli6Z5eAr_IYdbicKo_pzqiupdxvu4u-jKt-F4KojU9avgWFAB01isHHO5Z1vzVJ6XDilWeah5DvHc1lkcPCXtbBGvykfFqJIBhthnFi0f_S4HV-IlOKwvKbfmL5GplD7H-DjUA5UdHjw8HoJa6uQxhbERy5dZlYqxN918aL147Afq4LuPoWUJULEsYULwUuA6HspemIKUltHacOAxZgP4OLVkB3zwssj8E6rMtU1puupHiL7J66fFaR3co71gzzlvl8R2Xi3xEQdpigxxCUAsZWMrSrITRBnKPKGF1CrFEhU6FP6bQAQ6UuhAdqLoJihwVnMTyY9fGUriwCkrQu5gK7ZQlnXyluV0J_5xWh4sOaPmwmeiUXMBPN0iGb7z24lyHaI3QXz3kGlJBnIFhseJTJo3ed66Z_LAf8I_hFC6s_sIioEmRgd4tm3Q1U05ETKrptnzo8Ac4AOTdJtbQv0uDQSkoefUbebu7x6L9Dns04VSvDPKLwlFQd81sl9DYmi9SPDxKT7S6gfG6WjJ9z35eNSR01QW1QIgAAhMU8UX4o7QQaXnUZxfZeYRMXlzu_xb4KSREvc_FeLJ-IvnPFgzryAgLi_Sipl__Eul0sjrREPYJE1GxBOIoURGa-Bsmc3yy8aWArxv_HGpbLzwjmH8TaMvB3P_4tkvT-5IjJlpe0UrR1ssqasUtwfH9yWv5-4i-EdJrJ_SJ4Hl1Vlj9zi9lEFr33Zs96kn8ZOkBHp0m7Sxr5xP-krSxQkROIpu0d02kIqQ3nob-kGbnAf0zkmH6pS3H4mG2Zksu8KcGvghx7XTl3qBOJ-ZY4vlev2cSMBfMmnbUHKvMlz4YsmTGR1JPntDguA8UJJ1UZCex4E_W3KcHwd4qvzqgMZNjdarIvGjlmnKmoL1RV7EqUsBkpk-jauY0SqoWsIIf4b6O9Y3fQRRJURLeIfGCTmlxl-df-4yjqUhxUXTaQsX2KlEJ3tZK-ZI9FdKMzqPip2oMFwf2XfLIyIuRA0NU5fDRIxqPUzYv6RQ-zhXXB1QscsAtyf1t-LsaVw__1Vfj6V3Ups4pNyiwMAZg1z9DaIHht--VfgCdqT4RLcaGI8eEDrjkOc9G_iLkLBCfOB7EZkcXT20Lc1Silxa--dZsaYp5Tni8dz6f5YWg=="}],
-      "role": "model"}, {"parts": [{"functionResponse": {"name": "read_website", "response":
-      {"result": "Content from https://www.example.com/ai-agent-market-report: This
-      article discusses key insights about the topic including market size ($50B),
-      growth rate (15% YoY), and major players in the industry."}}}], "role": "user"},
-      {"parts": [{"functionCall": {"args": {"findings": "The AI agent market is currently
-      valued at $50 billion and is experiencing a strong growth rate of 15% year-over-year.
-      Key players in the industry are contributing to this expansion, driven by increasing
-      adoption across various sectors.", "title": "Current State of the AI Agent Market"},
-      "name": "generate_report"}, "thoughtSignature": "CuACAXLI2nzhub94iTgphfrBnaQV13Wv0-kRJj-l9jEDfxsyNg9eGnhxRfj4cued3Mgvv1CR9vkpfDV_V9x57TVWLNwPsVvsTgZKI0pwmV355sUCRKqAyfRBwDWhn0UAl9-sYNFCKUJCp8G5QBGfrar1lYLltX_z83d4O13Wn5Ugvxco9o4CdxnnPJOWkTPETRgXA_1HSdEiwGNqt0A3lKYkGRXQx-XyK54lDwmOBg-Yx4ZVgUxANXLK1z91NF_6cpmSVgoE2sL0VrIHISYs4XdUCj1fL3R7DpnZdrrZhmqnTjEgkeR1C3BR5GJeSUmg-kmqjPSPnP0NYiZo9H9SGL_ewGz3wg-GKcILAa4nD7_tfdqIMbAff8PJemwJE4ONT5zAmJ69_NFj0i1X01v04E8f2NdHewPSsKO5mptk5qzWxoW3G3uUhXccxk62EydTsESf6WRwolsmphaGgVE9AwuhzQ=="}],
-      "role": "model"}, {"parts": [{"functionResponse": {"name": "generate_report",
-      "response": {"result": "# Current State of the AI Agent Market\n\n## Executive
-      Summary\nThe AI agent market is currently valued at $50 billion and is experiencing
-      a strong growth rate of 15% year-over-year. Key players in the industry are
-      contributing to this expansion, driven by increasing adoption across various
-      sectors.\n\n## Conclusion\nBased on the analysis, the market shows strong growth
-      potential."}}}], "role": "user"}], "systemInstruction": {"parts": [{"text":
-      "You are Research Analyst. An experienced analyst skilled at gathering information
-      and synthesizing findings into actionable insights.\nYour personal goal is:
-      Conduct thorough research and produce insightful reports"}], "role": "user"},
-      "tools": [{"functionDeclarations": [{"description": "Search the web for information
-      on a given topic.\n\nArgs:\n    query: The search query to look up.\n\nReturns:\n    Search
-      results as a string.", "name": "web_search", "parameters_json_schema": {"properties":
-      {"query": {"title": "Query", "type": "string"}}, "required": ["query"], "type":
-      "object", "additionalProperties": false}}, {"description": "Read and extract
-      content from a website URL.\n\nArgs:\n    url: The URL of the website to read.\n\nReturns:\n    The
-      extracted content from the website.", "name": "read_website", "parameters_json_schema":
-      {"properties": {"url": {"title": "Url", "type": "string"}}, "required": ["url"],
-      "type": "object", "additionalProperties": false}}, {"description": "Generate
-      a structured report based on research findings.\n\nArgs:\n    title: The title
-      of the report.\n    findings: The research findings to include.\n\nReturns:\n    A
-      formatted report string.", "name": "generate_report", "parameters_json_schema":
-      {"properties": {"title": {"title": "Title", "type": "string"}, "findings": {"title":
-      "Findings", "type": "string"}}, "required": ["title", "findings"], "type": "object",
-      "additionalProperties": false}}]}], "generationConfig": {"stopSequences": ["\nObservation:"]}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '8941'
-      content-type:
-      - application/json
-      host:
-      - generativelanguage.googleapis.com
-      x-goog-api-client:
-      - google-genai-sdk/1.49.0 gl-python/3.13.3
-      x-goog-api-key:
-      - X-GOOG-API-KEY-XXX
-    method: POST
-    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent
-  response:
-    body:
-      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
-        [\n          {\n            \"text\": \"The research on the current state
-        of the AI agent market has been completed. A report has been generated with
-        the following key findings:\\n\\n**Current State of the AI Agent Market**\\n\\n**Executive
-        Summary**\\nThe AI agent market is currently valued at $50 billion and is
-        experiencing a strong growth rate of 15% year-over-year. Key players in the
-        industry are contributing to this expansion, driven by increasing adoption
-        across various sectors.\\n\\n**Conclusion**\\nBased on the analysis, the market
-        shows strong growth potential.\",\n            \"thoughtSignature\": \"CpIDAXLI2nwVVOjjKtAsnvvRhuJU79oCZksDIi1i7PcIr+FkXVHX8sS8kM0optXLnRQWDRKKxUDKA9C1myhIfnDfc3ef44xc4UaczwM80/TbYanden25qpZRA2kztBz9HiWEPyGjeX8M/8BGAj7mh3q6hwPtTFtmhFTzlw190YQoZLELqOyQzTSECt8roXPdWN1XhU/NbHg4x+H3IFSQ2HZKxbY/JC6tx5FYYh444tIT4798iVHI5HOUVb1pfdLfV45ju/DOD+pTONuqVcTX+jgusjoaH32pdu4Q19atg5BR6zanqwv93vkYPXx0hF4rI8FHtV9jrqwtjLqzXvh7LANtNpCvO3HG++lIoeRTy5RzfYQRkLkrfuLWW+xkGDYQh+CQ7jbeurx344pHBjzZTVDaSNTA0QMTYwDH7YUkxIsyw5Hv1F8tpVvjgoKqvJnar1d/EvrbiOwygpiEZOrmPEn/DKp4qPk2+hhFS4JpcnNGva9cFM22ObwHydIQdoXHOX3wci0nhshAZ0e8hd5u820gfrya\"\n
-        \         }\n        ],\n        \"role\": \"model\"\n      },\n      \"finishReason\":
-        \"STOP\",\n      \"index\": 0\n    }\n  ],\n  \"usageMetadata\": {\n    \"promptTokenCount\":
-        727,\n    \"candidatesTokenCount\": 108,\n    \"totalTokenCount\": 910,\n
-        \   \"cachedContentTokenCount\": 375,\n    \"promptTokensDetails\": [\n      {\n
-        \       \"modality\": \"TEXT\",\n        \"tokenCount\": 727\n      }\n    ],\n
-        \   \"cacheTokensDetails\": [\n      {\n        \"modality\": \"TEXT\",\n
-        \       \"tokenCount\": 375\n      }\n    ],\n    \"thoughtsTokenCount\":
-        75\n  },\n  \"modelVersion\": \"gemini-2.5-flash\",\n  \"responseId\": \"kUWCabvgOafg_uMP06Ga0QI\"\n}\n"
-    headers:
-      Alt-Svc:
-      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
-      Content-Type:
-      - application/json; charset=UTF-8
-      Date:
-      - Tue, 03 Feb 2026 18:59:30 GMT
-      Server:
-      - scaffolding on HTTPServer2
-      Server-Timing:
-      - gfet4t7; dur=3125
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Origin
-      - X-Origin
-      - Referer
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      X-Frame-Options:
-      - X-FRAME-OPTIONS-XXX
-      X-XSS-Protection:
-      - '0'
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cassettes/utilities/TestOpenAIStructuredPlanning.test_openai_research_workflow_generates_steps.yaml

@@ -1,708 +0,0 @@
-interactions:
-- request:
-    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
-      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
-      a focused execution plan for the following task:\n\n## Task\nResearch the current
-      state of the AI agent market:\n1. Search for recent information about AI agents
-      and their market trends\n2. Read detailed content from a relevant industry source\n3.
-      Generate a brief report summarizing the key findings\n\nUse the available tools
-      for each step.\n\n## Expected Output\nComplete the task successfully\n\n## Available
-      Tools\nweb_search, read_website, generate_report\n\n## Instructions\nCreate
-      ONLY the essential steps needed to complete this task. Use the MINIMUM number
-      of steps required - do NOT pad your plan with unnecessary steps. Most tasks
-      need only 2-5 steps.\n\nFor each step:\n- State the specific action to take\n-
-      Specify which tool to use (if any)\n- Note dependencies on previous steps if
-      this step requires their output\n- If a step involves multiple items (e.g.,
-      research 3 competitors), note this explicitly\n\nDo NOT include:\n- Setup or
-      preparation steps that are obvious\n- Verification steps unless critical\n-
-      Documentation or cleanup steps unless explicitly required\n- Generic steps like
-      \"review results\" or \"finalize output\"\n\nAfter your plan, state:\n- \"READY:
-      I am ready to execute the task.\" if the plan is complete\n- \"NOT READY: I
-      need to refine my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
-      or refine a reasoning plan for a task with structured steps","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"A
-      brief summary of the overall plan."},"steps":{"type":"array","description":"List
-      of discrete steps to execute the plan","items":{"type":"object","properties":{"step_number":{"type":"integer","description":"Step
-      number (1-based)"},"description":{"type":"string","description":"What to do
-      in this step"},"tool_to_use":{"type":["string","null"],"description":"Tool to
-      use for this step, or null if no tool needed"},"depends_on":{"type":"array","items":{"type":"integer"},"description":"Step
-      numbers this step depends on (empty array if none)"}},"required":["step_number","description","tool_to_use","depends_on"],"additionalProperties":false}},"ready":{"type":"boolean","description":"Whether
-      the agent is ready to execute the task."}},"required":["plan","steps","ready"],"additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '2619'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D5Fu3HzCCoZJXtY9WqBmBv4QA4PS8\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770145143,\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_bVEiQHpiVX9FEfuWVwTe8XGj\",\n            \"type\":
-        \"function\",\n            \"function\": {\n              \"name\": \"create_reasoning_plan\",\n
-        \             \"arguments\": \"{\\\"plan\\\":\\\"Research the current state
-        of the AI agent market by gathering recent market trend data, reading in-depth
-        content from a reliable industry source, and generating a concise report.\\\",\\\"steps\\\":[{\\\"step_number\\\":1,\\\"description\\\":\\\"Search
-        for recent information about AI agents and their market trends.\\\",\\\"tool_to_use\\\":\\\"web_search\\\",\\\"depends_on\\\":[]},{\\\"step_number\\\":2,\\\"description\\\":\\\"Read
-        detailed content from a relevant industry source found during the search.\\\",\\\"tool_to_use\\\":\\\"read_website\\\",\\\"depends_on\\\":[1]},{\\\"step_number\\\":3,\\\"description\\\":\\\"Generate
-        a brief report summarizing the key findings from the gathered information.\\\",\\\"tool_to_use\\\":\\\"generate_report\\\",\\\"depends_on\\\":[1,2]}],\\\"ready\\\":true}\"\n
-        \           }\n          }\n        ],\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 480,\n    \"completion_tokens\":
-        153,\n    \"total_tokens\": 633,\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_fa7f5b168b\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 18:59:05 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '2629'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Research Analyst. An experienced
-      analyst skilled at gathering information and synthesizing findings into actionable
-      insights.\nYour personal goal is: Conduct thorough research and produce insightful
-      reports"},{"role":"user","content":"\nCurrent Task: Research the current state
-      of the AI agent market:\n1. Search for recent information about AI agents and
-      their market trends\n2. Read detailed content from a relevant industry source\n3.
-      Generate a brief report summarizing the key findings\n\nUse the available tools
-      for each step."}],"model":"gpt-4o","tool_choice":"auto","tools":[{"type":"function","function":{"name":"web_search","description":"Search
-      the web for information on a given topic.\n\nArgs:\n    query: The search query
-      to look up.\n\nReturns:\n    Search results as a string.","strict":true,"parameters":{"properties":{"query":{"title":"Query","type":"string"}},"required":["query"],"type":"object","additionalProperties":false}}},{"type":"function","function":{"name":"read_website","description":"Read
-      and extract content from a website URL.\n\nArgs:\n    url: The URL of the website
-      to read.\n\nReturns:\n    The extracted content from the website.","strict":true,"parameters":{"properties":{"url":{"title":"Url","type":"string"}},"required":["url"],"type":"object","additionalProperties":false}}},{"type":"function","function":{"name":"generate_report","description":"Generate
-      a structured report based on research findings.\n\nArgs:\n    title: The title
-      of the report.\n    findings: The research findings to include.\n\nReturns:\n    A
-      formatted report string.","strict":true,"parameters":{"properties":{"title":{"title":"Title","type":"string"},"findings":{"title":"Findings","type":"string"}},"required":["title","findings"],"type":"object","additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1849'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D5Fu6H5Oz7CA6xtmPwoBDIAr59nyJ\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770145146,\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_QlnPEA94TbaFA83eRDhOHXRY\",\n            \"type\":
-        \"function\",\n            \"function\": {\n              \"name\": \"web_search\",\n
-        \             \"arguments\": \"{\\\"query\\\":\\\"current state of AI agent
-        market 2023\\\"}\"\n            }\n          }\n        ],\n        \"refusal\":
-        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
-        \     \"finish_reason\": \"tool_calls\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
-        267,\n    \"completion_tokens\": 22,\n    \"total_tokens\": 289,\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_fa7f5b168b\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 18:59:07 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '752'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Research Analyst. An experienced
-      analyst skilled at gathering information and synthesizing findings into actionable
-      insights.\nYour personal goal is: Conduct thorough research and produce insightful
-      reports"},{"role":"user","content":"\nCurrent Task: Research the current state
-      of the AI agent market:\n1. Search for recent information about AI agents and
-      their market trends\n2. Read detailed content from a relevant industry source\n3.
-      Generate a brief report summarizing the key findings\n\nUse the available tools
-      for each step."},{"role":"assistant","content":null,"tool_calls":[{"id":"call_QlnPEA94TbaFA83eRDhOHXRY","type":"function","function":{"name":"web_search","arguments":"{\"query\":\"current
-      state of AI agent market 2023\"}"}}]},{"role":"tool","tool_call_id":"call_QlnPEA94TbaFA83eRDhOHXRY","name":"web_search","content":"Search
-      results for ''current state of AI agent market 2023'': Found 3 relevant articles
-      about the topic including market analysis, competitor data, and industry trends."}],"model":"gpt-4o","tool_choice":"auto","tools":[{"type":"function","function":{"name":"web_search","description":"Search
-      the web for information on a given topic.\n\nArgs:\n    query: The search query
-      to look up.\n\nReturns:\n    Search results as a string.","strict":true,"parameters":{"properties":{"query":{"title":"Query","type":"string"}},"required":["query"],"type":"object","additionalProperties":false}}},{"type":"function","function":{"name":"read_website","description":"Read
-      and extract content from a website URL.\n\nArgs:\n    url: The URL of the website
-      to read.\n\nReturns:\n    The extracted content from the website.","strict":true,"parameters":{"properties":{"url":{"title":"Url","type":"string"}},"required":["url"],"type":"object","additionalProperties":false}}},{"type":"function","function":{"name":"generate_report","description":"Generate
-      a structured report based on research findings.\n\nArgs:\n    title: The title
-      of the report.\n    findings: The research findings to include.\n\nReturns:\n    A
-      formatted report string.","strict":true,"parameters":{"properties":{"title":{"title":"Title","type":"string"},"findings":{"title":"Findings","type":"string"}},"required":["title","findings"],"type":"object","additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '2320'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D5Fu7QFl2h9pGJ0uhX6g4Fi4MMzMX\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770145147,\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_sOaxpAdq5dvpRhUJMAct2oNP\",\n            \"type\":
-        \"function\",\n            \"function\": {\n              \"name\": \"read_website\",\n
-        \             \"arguments\": \"{\\\"url\\\": \\\"https://www.example.com/ai-agent-market-analysis-2023\\\"}\"\n
-        \           }\n          },\n          {\n            \"id\": \"call_1GRSbggp4SYHg5WqAUQx5Dce\",\n
-        \           \"type\": \"function\",\n            \"function\": {\n              \"name\":
-        \"read_website\",\n              \"arguments\": \"{\\\"url\\\": \\\"https://www.example.com/ai-agent-competitor-data-2023\\\"}\"\n
-        \           }\n          },\n          {\n            \"id\": \"call_43s9ebATowN3hA5piPjL2z5N\",\n
-        \           \"type\": \"function\",\n            \"function\": {\n              \"name\":
-        \"read_website\",\n              \"arguments\": \"{\\\"url\\\": \\\"https://www.example.com/ai-agent-industry-trends-2023\\\"}\"\n
-        \           }\n          }\n        ],\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 330,\n    \"completion_tokens\":
-        101,\n    \"total_tokens\": 431,\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_fa7f5b168b\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 18:59:09 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '1885'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Research Analyst. An experienced
-      analyst skilled at gathering information and synthesizing findings into actionable
-      insights.\nYour personal goal is: Conduct thorough research and produce insightful
-      reports"},{"role":"user","content":"\nCurrent Task: Research the current state
-      of the AI agent market:\n1. Search for recent information about AI agents and
-      their market trends\n2. Read detailed content from a relevant industry source\n3.
-      Generate a brief report summarizing the key findings\n\nUse the available tools
-      for each step."},{"role":"assistant","content":null,"tool_calls":[{"id":"call_QlnPEA94TbaFA83eRDhOHXRY","type":"function","function":{"name":"web_search","arguments":"{\"query\":\"current
-      state of AI agent market 2023\"}"}}]},{"role":"tool","tool_call_id":"call_QlnPEA94TbaFA83eRDhOHXRY","name":"web_search","content":"Search
-      results for ''current state of AI agent market 2023'': Found 3 relevant articles
-      about the topic including market analysis, competitor data, and industry trends."},{"role":"assistant","content":null,"tool_calls":[{"id":"call_sOaxpAdq5dvpRhUJMAct2oNP","type":"function","function":{"name":"read_website","arguments":"{\"url\":
-      \"https://www.example.com/ai-agent-market-analysis-2023\"}"}},{"id":"call_1GRSbggp4SYHg5WqAUQx5Dce","type":"function","function":{"name":"read_website","arguments":"{\"url\":
-      \"https://www.example.com/ai-agent-competitor-data-2023\"}"}},{"id":"call_43s9ebATowN3hA5piPjL2z5N","type":"function","function":{"name":"read_website","arguments":"{\"url\":
-      \"https://www.example.com/ai-agent-industry-trends-2023\"}"}}]},{"role":"tool","tool_call_id":"call_sOaxpAdq5dvpRhUJMAct2oNP","name":"read_website","content":"Content
-      from https://www.example.com/ai-agent-market-analysis-2023: This article discusses
-      key insights about the topic including market size ($50B), growth rate (15%
-      YoY), and major players in the industry."},{"role":"tool","tool_call_id":"call_1GRSbggp4SYHg5WqAUQx5Dce","name":"read_website","content":"Content
-      from https://www.example.com/ai-agent-competitor-data-2023: This article discusses
-      key insights about the topic including market size ($50B), growth rate (15%
-      YoY), and major players in the industry."},{"role":"tool","tool_call_id":"call_43s9ebATowN3hA5piPjL2z5N","name":"read_website","content":"Content
-      from https://www.example.com/ai-agent-industry-trends-2023: This article discusses
-      key insights about the topic including market size ($50B), growth rate (15%
-      YoY), and major players in the industry."}],"model":"gpt-4o","tool_choice":"auto","tools":[{"type":"function","function":{"name":"web_search","description":"Search
-      the web for information on a given topic.\n\nArgs:\n    query: The search query
-      to look up.\n\nReturns:\n    Search results as a string.","strict":true,"parameters":{"properties":{"query":{"title":"Query","type":"string"}},"required":["query"],"type":"object","additionalProperties":false}}},{"type":"function","function":{"name":"read_website","description":"Read
-      and extract content from a website URL.\n\nArgs:\n    url: The URL of the website
-      to read.\n\nReturns:\n    The extracted content from the website.","strict":true,"parameters":{"properties":{"url":{"title":"Url","type":"string"}},"required":["url"],"type":"object","additionalProperties":false}}},{"type":"function","function":{"name":"generate_report","description":"Generate
-      a structured report based on research findings.\n\nArgs:\n    title: The title
-      of the report.\n    findings: The research findings to include.\n\nReturns:\n    A
-      formatted report string.","strict":true,"parameters":{"properties":{"title":{"title":"Title","type":"string"},"findings":{"title":"Findings","type":"string"}},"required":["title","findings"],"type":"object","additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '3811'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D5Fu95gX9R1zxpiJUa1wSOzIGA9CL\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770145149,\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_QjEKbvT6OnKkCOTvwTu0TmAK\",\n            \"type\":
-        \"function\",\n            \"function\": {\n              \"name\": \"generate_report\",\n
-        \             \"arguments\": \"{\\\"title\\\":\\\"Current State of the AI
-        Agent Market 2023\\\",\\\"findings\\\":\\\"1. Market Size: The AI agent market
-        is currently valued at $50 billion.\\\\n2. Growth Rate: The industry is experiencing
-        a growth rate of 15% year-over-year.\\\\n3. Major Players: Significant companies
-        in this space include tech giants and specialized AI startups.\\\\n4. Market
-        Trends: The demand for AI agents is being driven by improvements in machine
-        learning algorithms and increasing adoption in customer service and automation
-        processes.\\\\n5. Competitive Landscape: The market is competitive with ongoing
-        innovation and investment in developing more advanced AI capabilities.\\\\n6.
-        Future Prospects: Continued growth is expected as businesses further integrate
-        AI agents into their operations for efficiency gains and customer engagement.\\\"}\"\n
-        \           }\n          }\n        ],\n        \"refusal\": null,\n        \"annotations\":
-        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n
-        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 587,\n    \"completion_tokens\":
-        163,\n    \"total_tokens\": 750,\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_fa7f5b168b\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 18:59:12 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '3444'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Research Analyst. An experienced
-      analyst skilled at gathering information and synthesizing findings into actionable
-      insights.\nYour personal goal is: Conduct thorough research and produce insightful
-      reports"},{"role":"user","content":"\nCurrent Task: Research the current state
-      of the AI agent market:\n1. Search for recent information about AI agents and
-      their market trends\n2. Read detailed content from a relevant industry source\n3.
-      Generate a brief report summarizing the key findings\n\nUse the available tools
-      for each step."},{"role":"assistant","content":null,"tool_calls":[{"id":"call_QlnPEA94TbaFA83eRDhOHXRY","type":"function","function":{"name":"web_search","arguments":"{\"query\":\"current
-      state of AI agent market 2023\"}"}}]},{"role":"tool","tool_call_id":"call_QlnPEA94TbaFA83eRDhOHXRY","name":"web_search","content":"Search
-      results for ''current state of AI agent market 2023'': Found 3 relevant articles
-      about the topic including market analysis, competitor data, and industry trends."},{"role":"assistant","content":null,"tool_calls":[{"id":"call_sOaxpAdq5dvpRhUJMAct2oNP","type":"function","function":{"name":"read_website","arguments":"{\"url\":
-      \"https://www.example.com/ai-agent-market-analysis-2023\"}"}},{"id":"call_1GRSbggp4SYHg5WqAUQx5Dce","type":"function","function":{"name":"read_website","arguments":"{\"url\":
-      \"https://www.example.com/ai-agent-competitor-data-2023\"}"}},{"id":"call_43s9ebATowN3hA5piPjL2z5N","type":"function","function":{"name":"read_website","arguments":"{\"url\":
-      \"https://www.example.com/ai-agent-industry-trends-2023\"}"}}]},{"role":"tool","tool_call_id":"call_sOaxpAdq5dvpRhUJMAct2oNP","name":"read_website","content":"Content
-      from https://www.example.com/ai-agent-market-analysis-2023: This article discusses
-      key insights about the topic including market size ($50B), growth rate (15%
-      YoY), and major players in the industry."},{"role":"tool","tool_call_id":"call_1GRSbggp4SYHg5WqAUQx5Dce","name":"read_website","content":"Content
-      from https://www.example.com/ai-agent-competitor-data-2023: This article discusses
-      key insights about the topic including market size ($50B), growth rate (15%
-      YoY), and major players in the industry."},{"role":"tool","tool_call_id":"call_43s9ebATowN3hA5piPjL2z5N","name":"read_website","content":"Content
-      from https://www.example.com/ai-agent-industry-trends-2023: This article discusses
-      key insights about the topic including market size ($50B), growth rate (15%
-      YoY), and major players in the industry."},{"role":"assistant","content":null,"tool_calls":[{"id":"call_QjEKbvT6OnKkCOTvwTu0TmAK","type":"function","function":{"name":"generate_report","arguments":"{\"title\":\"Current
-      State of the AI Agent Market 2023\",\"findings\":\"1. Market Size: The AI agent
-      market is currently valued at $50 billion.\\n2. Growth Rate: The industry is
-      experiencing a growth rate of 15% year-over-year.\\n3. Major Players: Significant
-      companies in this space include tech giants and specialized AI startups.\\n4.
-      Market Trends: The demand for AI agents is being driven by improvements in machine
-      learning algorithms and increasing adoption in customer service and automation
-      processes.\\n5. Competitive Landscape: The market is competitive with ongoing
-      innovation and investment in developing more advanced AI capabilities.\\n6.
-      Future Prospects: Continued growth is expected as businesses further integrate
-      AI agents into their operations for efficiency gains and customer engagement.\"}"}}]},{"role":"tool","tool_call_id":"call_QjEKbvT6OnKkCOTvwTu0TmAK","name":"generate_report","content":"#
-      Current State of the AI Agent Market 2023\n\n## Executive Summary\n1. Market
-      Size: The AI agent market is currently valued at $50 billion.\n2. Growth Rate:
-      The industry is experiencing a growth rate of 15% year-over-year.\n3. Major
-      Players: Significant companies in this space include tech giants and specialized
-      AI startups.\n4. Market Trends: The demand for AI agents is being driven by
-      improvements in machine learning algorithms and increasing adoption in customer
-      service and automation processes.\n5. Competitive Landscape: The market is competitive
-      with ongoing innovation and investment in developing more advanced AI capabilities.\n6.
-      Future Prospects: Continued growth is expected as businesses further integrate
-      AI agents into their operations for efficiency gains and customer engagement.\n\n##
-      Conclusion\nBased on the analysis, the market shows strong growth potential."}],"model":"gpt-4o","tool_choice":"auto","tools":[{"type":"function","function":{"name":"web_search","description":"Search
-      the web for information on a given topic.\n\nArgs:\n    query: The search query
-      to look up.\n\nReturns:\n    Search results as a string.","strict":true,"parameters":{"properties":{"query":{"title":"Query","type":"string"}},"required":["query"],"type":"object","additionalProperties":false}}},{"type":"function","function":{"name":"read_website","description":"Read
-      and extract content from a website URL.\n\nArgs:\n    url: The URL of the website
-      to read.\n\nReturns:\n    The extracted content from the website.","strict":true,"parameters":{"properties":{"url":{"title":"Url","type":"string"}},"required":["url"],"type":"object","additionalProperties":false}}},{"type":"function","function":{"name":"generate_report","description":"Generate
-      a structured report based on research findings.\n\nArgs:\n    title: The title
-      of the report.\n    findings: The research findings to include.\n\nReturns:\n    A
-      formatted report string.","strict":true,"parameters":{"properties":{"title":{"title":"Title","type":"string"},"findings":{"title":"Findings","type":"string"}},"required":["title","findings"],"type":"object","additionalProperties":false}}}]}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '5771'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-D5FuCTJhAII96iBV05ECT71cV6QmJ\",\n  \"object\":
-        \"chat.completion\",\n  \"created\": 1770145152,\n  \"model\": \"gpt-4o-2024-08-06\",\n
-        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-        \"assistant\",\n        \"content\": \"The research on the current state of
-        the AI agent market indicates a robust and rapidly growing industry. Here\u2019s
-        a summary of the findings:\\n\\n1. **Market Size**: The AI agent market is
-        currently valued at $50 billion.\\n2. **Growth Rate**: It is experiencing
-        a significant growth rate of 15% year-over-year.\\n3. **Major Players**: The
-        market is dominated by tech giants and specialized AI startups.\\n4. **Market
-        Trends**: The increasing adoption of machine learning algorithms and the integration
-        of AI in customer service and automation are key drivers.\\n5. **Competitive
-        Landscape**: There is substantial competition and continuous innovation in
-        AI capabilities.\\n6. **Future Prospects**: The sector is expected to keep
-        growing as businesses increasingly use AI agents for efficiency and improved
-        customer engagement.\\n\\nThis analysis highlights significant opportunities
-        in the AI agent sector, underlining its importance in future technological
-        advancements.\",\n        \"refusal\": null,\n        \"annotations\": []\n
-        \     },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n
-        \ ],\n  \"usage\": {\n    \"prompt_tokens\": 920,\n    \"completion_tokens\":
-        182,\n    \"total_tokens\": 1102,\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_fa7f5b168b\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Tue, 03 Feb 2026 18:59:16 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '3456'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai/tests/cli/test_plus_api.py

@@ -28,19 +28,7 @@ class TestPlusAPI(unittest.TestCase):
         response = self.api.login_to_tool_repository()
 
         mock_make_request.assert_called_once_with(
-            "POST", "/crewai_plus/api/v1/tools/login", json={}
-        )
-        self.assertEqual(response, mock_response)
-
-    @patch("crewai.cli.plus_api.PlusAPI._make_request")
-    def test_login_to_tool_repository_with_user_identifier(self, mock_make_request):
-        mock_response = MagicMock()
-        mock_make_request.return_value = mock_response
-
-        response = self.api.login_to_tool_repository(user_identifier="test-hash-123")
-
-        mock_make_request.assert_called_once_with(
-            "POST", "/crewai_plus/api/v1/tools/login", json={"user_identifier": "test-hash-123"}
+            "POST", "/crewai_plus/api/v1/tools/login"
         )
         self.assertEqual(response, mock_response)
 
@@ -79,7 +67,7 @@ class TestPlusAPI(unittest.TestCase):
         response = self.api.login_to_tool_repository()
 
         self.assert_request_with_org_id(
-            mock_client_instance, "POST", "/crewai_plus/api/v1/tools/login", json={}
+            mock_client_instance, "POST", "/crewai_plus/api/v1/tools/login"
         )
         self.assertEqual(response, mock_response)
 

lib/crewai/tests/telemetry/test_telemetry.py

@@ -121,41 +121,3 @@ def test_telemetry_singleton_pattern():
         thread.join()
 
     assert all(instance is telemetry1 for instance in instances)
-
-
-def test_no_signal_handler_traceback_in_non_main_thread():
-    """Signal handler registration should be silently skipped in non-main threads.
-
-    Regression test for https://github.com/crewAIInc/crewAI/issues/4289
-    """
-    errors: list[Exception] = []
-    mock_holder: dict = {}
-
-    def init_in_thread():
-        try:
-            Telemetry._instance = None
-            with (
-                patch.dict(
-                    os.environ,
-                    {"CREWAI_DISABLE_TELEMETRY": "false", "OTEL_SDK_DISABLED": "false"},
-                ),
-                patch("crewai.telemetry.telemetry.TracerProvider"),
-                patch("signal.signal") as mock_signal,
-                patch("crewai.telemetry.telemetry.logger") as mock_logger,
-            ):
-                Telemetry()
-                mock_holder["signal"] = mock_signal
-                mock_holder["logger"] = mock_logger
-        except Exception as exc:
-            errors.append(exc)
-
-    thread = threading.Thread(target=init_in_thread)
-    thread.start()
-    thread.join()
-
-    assert not errors, f"Unexpected error: {errors}"
-    assert mock_holder, "Thread did not execute"
-    mock_holder["signal"].assert_not_called()
-    mock_holder["logger"].debug.assert_any_call(
-        "Skipping signal handler registration: not running in main thread"
-    )

lib/crewai/tests/test_flow.py

@@ -1843,53 +1843,3 @@ def test_cyclic_flow_works_with_persist_and_id_input():
             f"'{method}' should fire 3 times, "
             f"got {len(events)}: {execution_order}"
         )
-
-
-@pytest.mark.timeout(5)
-def test_self_listening_method_does_not_loop():
-    """A method whose @listen label matches its own name must not loop forever.
-
-    Without the guard, 'process' re-triggers itself on every completion,
-    running indefinitely (timeout → FAIL).  The fix caps method calls
-    and raises RecursionError (PASS).
-    """
-
-    class SelfListenFlow(Flow):
-        @start()
-        def begin(self):
-            return "process"
-
-        @router(begin)
-        def route(self):
-            return "process"
-
-        @listen("process")
-        def process(self):
-            pass
-
-    flow = SelfListenFlow()
-    with pytest.raises(RecursionError, match="infinite loop"):
-        flow.kickoff()
-
-
-def test_or_condition_self_listen_fires_once():
-    """or_() with a self-referencing label only fires once due to or_() guard."""
-    call_count = 0
-
-    class OrSelfListenFlow(Flow):
-        @start()
-        def begin(self):
-            return "process"
-
-        @router(begin)
-        def route(self):
-            return "process"
-
-        @listen(or_("other_trigger", "process"))
-        def process(self):
-            nonlocal call_count
-            call_count += 1
-
-    flow = OrSelfListenFlow()
-    flow.kickoff()
-    assert call_count == 1

lib/crewai/tests/tracing/test_tracing.py

@@ -840,87 +840,3 @@ class TestTraceListenerSetup:
                 mock_mark_failed.assert_called_once_with(
                     "test_batch_id_12345", "Internal Server Error"
                 )
-
-    def test_ephemeral_batch_includes_anon_id(self):
-        """Test that ephemeral batch initialization sends anon_id from get_user_id()"""
-        fake_user_id = "abc123def456"
-
-        with (
-            patch(
-                "crewai.events.listeners.tracing.trace_batch_manager.is_tracing_enabled_in_context",
-                return_value=True,
-            ),
-            patch(
-                "crewai.events.listeners.tracing.trace_batch_manager.get_user_id",
-                return_value=fake_user_id,
-            ),
-            patch(
-                "crewai.events.listeners.tracing.trace_batch_manager.should_auto_collect_first_time_traces",
-                return_value=False,
-            ),
-        ):
-            batch_manager = TraceBatchManager()
-
-            mock_response = MagicMock(
-                status_code=201,
-                json=MagicMock(return_value={
-                    "ephemeral_trace_id": "test-trace-id",
-                    "access_code": "TRACE-abc123",
-                }),
-            )
-
-            with patch.object(
-                batch_manager.plus_api,
-                "initialize_ephemeral_trace_batch",
-                return_value=mock_response,
-            ) as mock_init:
-                batch_manager.initialize_batch(
-                    user_context={"privacy_level": "standard"},
-                    execution_metadata={
-                        "execution_type": "crew",
-                        "crew_name": "test_crew",
-                    },
-                    use_ephemeral=True,
-                )
-
-                mock_init.assert_called_once()
-                payload = mock_init.call_args[0][0]
-                assert payload["user_identifier"] == fake_user_id
-                assert "ephemeral_trace_id" in payload
-
-    def test_non_ephemeral_batch_does_not_include_anon_id(self):
-        """Test that non-ephemeral batch initialization does not send anon_id"""
-        with (
-            patch(
-                "crewai.events.listeners.tracing.trace_batch_manager.is_tracing_enabled_in_context",
-                return_value=True,
-            ),
-            patch(
-                "crewai.events.listeners.tracing.trace_batch_manager.should_auto_collect_first_time_traces",
-                return_value=False,
-            ),
-        ):
-            batch_manager = TraceBatchManager()
-
-            mock_response = MagicMock(
-                status_code=201,
-                json=MagicMock(return_value={"trace_id": "test-trace-id"}),
-            )
-
-            with patch.object(
-                batch_manager.plus_api,
-                "initialize_trace_batch",
-                return_value=mock_response,
-            ) as mock_init:
-                batch_manager.initialize_batch(
-                    user_context={"privacy_level": "standard"},
-                    execution_metadata={
-                        "execution_type": "crew",
-                        "crew_name": "test_crew",
-                    },
-                    use_ephemeral=False,
-                )
-
-                mock_init.assert_called_once()
-                payload = mock_init.call_args[0][0]
-                assert "user_identifier" not in payload

lib/crewai/tests/utilities/test_agent_utils.py

@@ -80,7 +80,7 @@ class TestConvertToolsToOpenaiSchema:
     def test_converts_single_tool(self) -> None:
         """Test converting a single tool to OpenAI schema."""
         tools = [CalculatorTool()]
-        schemas, functions, _ = convert_tools_to_openai_schema(tools)
+        schemas, functions = convert_tools_to_openai_schema(tools)
 
         assert len(schemas) == 1
         assert len(functions) == 1
@@ -95,7 +95,7 @@ class TestConvertToolsToOpenaiSchema:
     def test_converts_multiple_tools(self) -> None:
         """Test converting multiple tools to OpenAI schema."""
         tools = [CalculatorTool(), SearchTool()]
-        schemas, functions, _ = convert_tools_to_openai_schema(tools)
+        schemas, functions = convert_tools_to_openai_schema(tools)
 
         assert len(schemas) == 2
         assert len(functions) == 2
@@ -113,7 +113,7 @@ class TestConvertToolsToOpenaiSchema:
     def test_functions_dict_contains_callables(self) -> None:
         """Test that the functions dict maps names to callable run methods."""
         tools = [CalculatorTool(), SearchTool()]
-        schemas, functions, _ = convert_tools_to_openai_schema(tools)
+        schemas, functions = convert_tools_to_openai_schema(tools)
 
         assert "calculator" in functions
         assert "web_search" in functions
@@ -123,14 +123,14 @@ class TestConvertToolsToOpenaiSchema:
     def test_function_can_be_called(self) -> None:
         """Test that the returned function can be called."""
         tools = [CalculatorTool()]
-        schemas, functions, _ = convert_tools_to_openai_schema(tools)
+        schemas, functions = convert_tools_to_openai_schema(tools)
 
         result = functions["calculator"](expression="2 + 2")
         assert result == "4"
 
     def test_empty_tools_list(self) -> None:
         """Test with an empty tools list."""
-        schemas, functions, _ = convert_tools_to_openai_schema([])
+        schemas, functions = convert_tools_to_openai_schema([])
 
         assert schemas == []
         assert functions == {}
@@ -138,7 +138,7 @@ class TestConvertToolsToOpenaiSchema:
     def test_schema_has_required_fields(self) -> None:
         """Test that the schema includes required fields information."""
         tools = [SearchTool()]
-        schemas, functions, _ = convert_tools_to_openai_schema(tools)
+        schemas, functions = convert_tools_to_openai_schema(tools)
 
         schema = schemas[0]
         params = schema["function"]["parameters"]
@@ -158,7 +158,7 @@ class TestConvertToolsToOpenaiSchema:
                 return "done"
 
         tools = [MinimalTool()]
-        schemas, functions, _ = convert_tools_to_openai_schema(tools)
+        schemas, functions = convert_tools_to_openai_schema(tools)
 
         assert len(schemas) == 1
         schema = schemas[0]
@@ -169,7 +169,7 @@ class TestConvertToolsToOpenaiSchema:
     def test_schema_structure_matches_openai_format(self) -> None:
         """Test that the schema structure matches OpenAI's expected format."""
         tools = [CalculatorTool()]
-        schemas, functions, _ = convert_tools_to_openai_schema(tools)
+        schemas, functions = convert_tools_to_openai_schema(tools)
 
         schema = schemas[0]
 
@@ -194,7 +194,7 @@ class TestConvertToolsToOpenaiSchema:
     def test_removes_redundant_schema_fields(self) -> None:
         """Test that redundant title and description are removed from parameters."""
         tools = [CalculatorTool()]
-        schemas, functions, _ = convert_tools_to_openai_schema(tools)
+        schemas, functions = convert_tools_to_openai_schema(tools)
 
         params = schemas[0]["function"]["parameters"]
         # Title should be removed as it's redundant with function name
@@ -203,7 +203,7 @@ class TestConvertToolsToOpenaiSchema:
     def test_preserves_field_descriptions(self) -> None:
         """Test that field descriptions are preserved in the schema."""
         tools = [SearchTool()]
-        schemas, functions, _ = convert_tools_to_openai_schema(tools)
+        schemas, functions = convert_tools_to_openai_schema(tools)
 
         params = schemas[0]["function"]["parameters"]
         query_prop = params["properties"]["query"]
@@ -215,7 +215,7 @@ class TestConvertToolsToOpenaiSchema:
     def test_preserves_default_values(self) -> None:
         """Test that default values are preserved in the schema."""
         tools = [SearchTool()]
-        schemas, functions, _ = convert_tools_to_openai_schema(tools)
+        schemas, functions = convert_tools_to_openai_schema(tools)
 
         params = schemas[0]["function"]["parameters"]
         max_results_prop = params["properties"]["max_results"]
@@ -265,7 +265,7 @@ class TestOptionalFieldsPreserveNull:
         """Optional[str] fields should include null in the schema so the LLM
         can send null instead of being forced to guess a value."""
         tools = [MCPStyleTool()]
-        schemas, _, _ = convert_tools_to_openai_schema(tools)
+        schemas, _ = convert_tools_to_openai_schema(tools)
 
         params = schemas[0]["function"]["parameters"]
         page_id_prop = params["properties"]["page_id"]
@@ -278,7 +278,7 @@ class TestOptionalFieldsPreserveNull:
     def test_optional_literal_allows_null(self) -> None:
         """Optional[Literal[...]] fields should include null."""
         tools = [MCPStyleTool()]
-        schemas, _, _ = convert_tools_to_openai_schema(tools)
+        schemas, _ = convert_tools_to_openai_schema(tools)
 
         params = schemas[0]["function"]["parameters"]
         filter_prop = params["properties"]["filter_type"]
@@ -290,7 +290,7 @@ class TestOptionalFieldsPreserveNull:
     def test_required_field_stays_non_null(self) -> None:
         """Required fields without Optional should NOT have null."""
         tools = [MCPStyleTool()]
-        schemas, _, _ = convert_tools_to_openai_schema(tools)
+        schemas, _ = convert_tools_to_openai_schema(tools)
 
         params = schemas[0]["function"]["parameters"]
         query_prop = params["properties"]["query"]
@@ -301,7 +301,7 @@ class TestOptionalFieldsPreserveNull:
     def test_all_fields_in_required_for_strict_mode(self) -> None:
         """All fields (including optional) must be in required for strict mode."""
         tools = [MCPStyleTool()]
-        schemas, _, _ = convert_tools_to_openai_schema(tools)
+        schemas, _ = convert_tools_to_openai_schema(tools)
 
         params = schemas[0]["function"]["parameters"]
         assert "query" in params["required"]

lib/crewai/tests/utilities/test_planning_types.py

@@ -1,389 +0,0 @@
-"""Tests for planning types (PlanStep, TodoItem, TodoList)."""
-
-import pytest
-from uuid import UUID
-
-from crewai.utilities.planning_types import (
-    PlanStep,
-    TodoItem,
-    TodoList,
-    TodoStatus,
-)
-
-
-class TestPlanStep:
-    """Tests for the PlanStep model."""
-
-    def test_plan_step_with_required_fields(self):
-        """Test PlanStep creation with only required fields."""
-        step = PlanStep(
-            step_number=1,
-            description="Research the topic",
-        )
-
-        assert step.step_number == 1
-        assert step.description == "Research the topic"
-        assert step.tool_to_use is None
-        assert step.depends_on == []
-
-    def test_plan_step_with_all_fields(self):
-        """Test PlanStep creation with all fields."""
-        step = PlanStep(
-            step_number=2,
-            description="Search for information",
-            tool_to_use="search_tool",
-            depends_on=[1],
-        )
-
-        assert step.step_number == 2
-        assert step.description == "Search for information"
-        assert step.tool_to_use == "search_tool"
-        assert step.depends_on == [1]
-
-    def test_plan_step_with_multiple_dependencies(self):
-        """Test PlanStep with multiple dependencies."""
-        step = PlanStep(
-            step_number=4,
-            description="Synthesize results",
-            depends_on=[1, 2, 3],
-        )
-
-        assert step.depends_on == [1, 2, 3]
-
-    def test_plan_step_requires_step_number(self):
-        """Test that step_number is required."""
-        with pytest.raises(ValueError):
-            PlanStep(description="Missing step number")
-
-    def test_plan_step_requires_description(self):
-        """Test that description is required."""
-        with pytest.raises(ValueError):
-            PlanStep(step_number=1)
-
-    def test_plan_step_serialization(self):
-        """Test PlanStep can be serialized to dict."""
-        step = PlanStep(
-            step_number=1,
-            description="Test step",
-            tool_to_use="test_tool",
-            depends_on=[],
-        )
-
-        data = step.model_dump()
-        assert data["step_number"] == 1
-        assert data["description"] == "Test step"
-        assert data["tool_to_use"] == "test_tool"
-        assert data["depends_on"] == []
-
-
-class TestTodoItem:
-    """Tests for the TodoItem model."""
-
-    def test_todo_item_with_required_fields(self):
-        """Test TodoItem creation with only required fields."""
-        todo = TodoItem(
-            step_number=1,
-            description="First task",
-        )
-
-        assert todo.step_number == 1
-        assert todo.description == "First task"
-        assert todo.status == "pending"
-        assert todo.tool_to_use is None
-        assert todo.depends_on == []
-        assert todo.result is None
-        # ID should be auto-generated
-        assert todo.id is not None
-        # Verify it's a valid UUID
-        UUID(todo.id)
-
-    def test_todo_item_with_all_fields(self):
-        """Test TodoItem creation with all fields."""
-        todo = TodoItem(
-            id="custom-id-123",
-            step_number=2,
-            description="Second task",
-            tool_to_use="search_tool",
-            status="running",
-            depends_on=[1],
-            result="Task completed",
-        )
-
-        assert todo.id == "custom-id-123"
-        assert todo.step_number == 2
-        assert todo.description == "Second task"
-        assert todo.tool_to_use == "search_tool"
-        assert todo.status == "running"
-        assert todo.depends_on == [1]
-        assert todo.result == "Task completed"
-
-    def test_todo_item_status_values(self):
-        """Test all valid status values."""
-        for status in ["pending", "running", "completed"]:
-            todo = TodoItem(
-                step_number=1,
-                description="Test",
-                status=status,
-            )
-            assert todo.status == status
-
-    def test_todo_item_auto_generates_unique_ids(self):
-        """Test that each TodoItem gets a unique auto-generated ID."""
-        todo1 = TodoItem(step_number=1, description="Task 1")
-        todo2 = TodoItem(step_number=2, description="Task 2")
-
-        assert todo1.id != todo2.id
-
-    def test_todo_item_serialization(self):
-        """Test TodoItem can be serialized to dict."""
-        todo = TodoItem(
-            step_number=1,
-            description="Test task",
-            status="pending",
-        )
-
-        data = todo.model_dump()
-        assert "id" in data
-        assert data["step_number"] == 1
-        assert data["description"] == "Test task"
-        assert data["status"] == "pending"
-
-
-class TestTodoList:
-    """Tests for the TodoList model."""
-
-    @pytest.fixture
-    def empty_todo_list(self):
-        """Create an empty TodoList."""
-        return TodoList()
-
-    @pytest.fixture
-    def sample_todo_list(self):
-        """Create a TodoList with sample items."""
-        return TodoList(
-            items=[
-                TodoItem(step_number=1, description="Step 1", status="completed"),
-                TodoItem(step_number=2, description="Step 2", status="running"),
-                TodoItem(step_number=3, description="Step 3", status="pending"),
-                TodoItem(step_number=4, description="Step 4", status="pending"),
-            ]
-        )
-
-    def test_empty_todo_list(self, empty_todo_list):
-        """Test empty TodoList properties."""
-        assert empty_todo_list.items == []
-        assert empty_todo_list.current_todo is None
-        assert empty_todo_list.next_pending is None
-        assert empty_todo_list.is_complete is False
-        assert empty_todo_list.pending_count == 0
-        assert empty_todo_list.completed_count == 0
-
-    def test_current_todo_property(self, sample_todo_list):
-        """Test current_todo returns the running item."""
-        current = sample_todo_list.current_todo
-        assert current is not None
-        assert current.step_number == 2
-        assert current.status == "running"
-
-    def test_current_todo_returns_none_when_no_running(self):
-        """Test current_todo returns None when no running items."""
-        todo_list = TodoList(
-            items=[
-                TodoItem(step_number=1, description="Step 1", status="completed"),
-                TodoItem(step_number=2, description="Step 2", status="pending"),
-            ]
-        )
-        assert todo_list.current_todo is None
-
-    def test_next_pending_property(self, sample_todo_list):
-        """Test next_pending returns the first pending item."""
-        next_item = sample_todo_list.next_pending
-        assert next_item is not None
-        assert next_item.step_number == 3
-        assert next_item.status == "pending"
-
-    def test_next_pending_returns_none_when_no_pending(self):
-        """Test next_pending returns None when no pending items."""
-        todo_list = TodoList(
-            items=[
-                TodoItem(step_number=1, description="Step 1", status="completed"),
-                TodoItem(step_number=2, description="Step 2", status="completed"),
-            ]
-        )
-        assert todo_list.next_pending is None
-
-    def test_is_complete_property_when_complete(self):
-        """Test is_complete returns True when all items completed."""
-        todo_list = TodoList(
-            items=[
-                TodoItem(step_number=1, description="Step 1", status="completed"),
-                TodoItem(step_number=2, description="Step 2", status="completed"),
-            ]
-        )
-        assert todo_list.is_complete is True
-
-    def test_is_complete_property_when_not_complete(self, sample_todo_list):
-        """Test is_complete returns False when items are pending."""
-        assert sample_todo_list.is_complete is False
-
-    def test_is_complete_false_for_empty_list(self, empty_todo_list):
-        """Test is_complete returns False for empty list."""
-        assert empty_todo_list.is_complete is False
-
-    def test_pending_count(self, sample_todo_list):
-        """Test pending_count returns correct count."""
-        assert sample_todo_list.pending_count == 2
-
-    def test_completed_count(self, sample_todo_list):
-        """Test completed_count returns correct count."""
-        assert sample_todo_list.completed_count == 1
-
-    def test_get_by_step_number(self, sample_todo_list):
-        """Test get_by_step_number returns correct item."""
-        item = sample_todo_list.get_by_step_number(3)
-        assert item is not None
-        assert item.step_number == 3
-        assert item.description == "Step 3"
-
-    def test_get_by_step_number_returns_none_for_missing(self, sample_todo_list):
-        """Test get_by_step_number returns None for non-existent step."""
-        item = sample_todo_list.get_by_step_number(99)
-        assert item is None
-
-    def test_mark_running(self, sample_todo_list):
-        """Test mark_running changes status correctly."""
-        sample_todo_list.mark_running(3)
-        item = sample_todo_list.get_by_step_number(3)
-        assert item.status == "running"
-
-    def test_mark_running_does_nothing_for_missing(self, sample_todo_list):
-        """Test mark_running handles missing step gracefully."""
-        # Should not raise an error
-        sample_todo_list.mark_running(99)
-
-    def test_mark_completed(self, sample_todo_list):
-        """Test mark_completed changes status correctly."""
-        sample_todo_list.mark_completed(3)
-        item = sample_todo_list.get_by_step_number(3)
-        assert item.status == "completed"
-        assert item.result is None
-
-    def test_mark_completed_with_result(self, sample_todo_list):
-        """Test mark_completed with result."""
-        sample_todo_list.mark_completed(3, result="Task output")
-        item = sample_todo_list.get_by_step_number(3)
-        assert item.status == "completed"
-        assert item.result == "Task output"
-
-    def test_mark_completed_does_nothing_for_missing(self, sample_todo_list):
-        """Test mark_completed handles missing step gracefully."""
-        # Should not raise an error
-        sample_todo_list.mark_completed(99, result="Some result")
-
-    def test_todo_list_workflow(self):
-        """Test a complete workflow through TodoList."""
-        # Create a todo list with 3 items
-        todo_list = TodoList(
-            items=[
-                TodoItem(
-                    step_number=1,
-                    description="Research",
-                    tool_to_use="search_tool",
-                ),
-                TodoItem(
-                    step_number=2,
-                    description="Analyze",
-                    depends_on=[1],
-                ),
-                TodoItem(
-                    step_number=3,
-                    description="Report",
-                    depends_on=[1, 2],
-                ),
-            ]
-        )
-
-        # Initial state
-        assert todo_list.pending_count == 3
-        assert todo_list.completed_count == 0
-        assert todo_list.is_complete is False
-
-        # Start first task
-        todo_list.mark_running(1)
-        assert todo_list.current_todo.step_number == 1
-        assert todo_list.next_pending.step_number == 2
-
-        # Complete first task
-        todo_list.mark_completed(1, result="Research done")
-        assert todo_list.current_todo is None
-        assert todo_list.completed_count == 1
-
-        # Start and complete second task
-        todo_list.mark_running(2)
-        todo_list.mark_completed(2, result="Analysis complete")
-        assert todo_list.completed_count == 2
-
-        # Start and complete third task
-        todo_list.mark_running(3)
-        todo_list.mark_completed(3, result="Report generated")
-
-        # Final state
-        assert todo_list.is_complete is True
-        assert todo_list.pending_count == 0
-        assert todo_list.completed_count == 3
-        assert todo_list.current_todo is None
-        assert todo_list.next_pending is None
-
-
-class TestTodoFromPlanStep:
-    """Tests for converting PlanStep to TodoItem."""
-
-    def test_convert_plan_step_to_todo_item(self):
-        """Test converting a PlanStep to TodoItem."""
-        step = PlanStep(
-            step_number=1,
-            description="Search for information",
-            tool_to_use="search_tool",
-            depends_on=[],
-        )
-
-        todo = TodoItem(
-            step_number=step.step_number,
-            description=step.description,
-            tool_to_use=step.tool_to_use,
-            depends_on=step.depends_on,
-            status="pending",
-        )
-
-        assert todo.step_number == step.step_number
-        assert todo.description == step.description
-        assert todo.tool_to_use == step.tool_to_use
-        assert todo.depends_on == step.depends_on
-        assert todo.status == "pending"
-
-    def test_convert_multiple_plan_steps_to_todo_list(self):
-        """Test converting multiple PlanSteps to a TodoList."""
-        steps = [
-            PlanStep(step_number=1, description="Step 1", tool_to_use="tool1"),
-            PlanStep(step_number=2, description="Step 2", depends_on=[1]),
-            PlanStep(step_number=3, description="Step 3", depends_on=[1, 2]),
-        ]
-
-        todos = []
-        for step in steps:
-            todo = TodoItem(
-                step_number=step.step_number,
-                description=step.description,
-                tool_to_use=step.tool_to_use,
-                depends_on=step.depends_on,
-                status="pending",
-            )
-            todos.append(todo)
-
-        todo_list = TodoList(items=todos)
-
-        assert len(todo_list.items) == 3
-        assert todo_list.pending_count == 3
-        assert todo_list.items[0].tool_to_use == "tool1"
-        assert todo_list.items[1].depends_on == [1]
-        assert todo_list.items[2].depends_on == [1, 2]

lib/crewai/tests/utilities/test_structured_planning.py

@@ -1,698 +0,0 @@
-"""Tests for structured planning with steps and todo generation.
-
-These tests verify that the planning system correctly generates structured
-PlanStep objects and converts them to TodoItems across different LLM providers.
-"""
-
-import json
-import os
-from unittest.mock import MagicMock, Mock, patch
-
-import pytest
-
-from crewai import Agent, PlanningConfig, Task
-from crewai.llm import LLM
-from crewai.utilities.planning_types import PlanStep, TodoItem, TodoList
-from crewai.utilities.reasoning_handler import (
-    FUNCTION_SCHEMA,
-    AgentReasoning,
-    ReasoningPlan,
-)
-
-
-class TestFunctionSchema:
-    """Tests for the FUNCTION_SCHEMA used in structured planning."""
-
-    def test_schema_has_required_structure(self):
-        """Test that FUNCTION_SCHEMA has the correct structure."""
-        assert FUNCTION_SCHEMA["type"] == "function"
-        assert "function" in FUNCTION_SCHEMA
-        assert FUNCTION_SCHEMA["function"]["name"] == "create_reasoning_plan"
-
-    def test_schema_parameters_structure(self):
-        """Test that parameters have correct structure."""
-        params = FUNCTION_SCHEMA["function"]["parameters"]
-        assert params["type"] == "object"
-        assert "properties" in params
-        assert "required" in params
-
-    def test_schema_has_plan_property(self):
-        """Test that schema includes plan property."""
-        props = FUNCTION_SCHEMA["function"]["parameters"]["properties"]
-        assert "plan" in props
-        assert props["plan"]["type"] == "string"
-
-    def test_schema_has_steps_property(self):
-        """Test that schema includes steps array property."""
-        props = FUNCTION_SCHEMA["function"]["parameters"]["properties"]
-        assert "steps" in props
-        assert props["steps"]["type"] == "array"
-
-    def test_schema_steps_items_structure(self):
-        """Test that steps items have correct structure."""
-        items = FUNCTION_SCHEMA["function"]["parameters"]["properties"]["steps"]["items"]
-        assert items["type"] == "object"
-        assert "properties" in items
-        assert "required" in items
-        assert "additionalProperties" in items
-        assert items["additionalProperties"] is False
-
-    def test_schema_step_properties(self):
-        """Test that step items have all required properties."""
-        step_props = FUNCTION_SCHEMA["function"]["parameters"]["properties"]["steps"]["items"]["properties"]
-
-        assert "step_number" in step_props
-        assert step_props["step_number"]["type"] == "integer"
-
-        assert "description" in step_props
-        assert step_props["description"]["type"] == "string"
-
-        assert "tool_to_use" in step_props
-        # tool_to_use should be nullable
-        assert step_props["tool_to_use"]["type"] == ["string", "null"]
-
-        assert "depends_on" in step_props
-        assert step_props["depends_on"]["type"] == "array"
-
-    def test_schema_step_required_fields(self):
-        """Test that step required fields are correct."""
-        required = FUNCTION_SCHEMA["function"]["parameters"]["properties"]["steps"]["items"]["required"]
-        assert "step_number" in required
-        assert "description" in required
-        assert "tool_to_use" in required
-        assert "depends_on" in required
-
-    def test_schema_has_ready_property(self):
-        """Test that schema includes ready property."""
-        props = FUNCTION_SCHEMA["function"]["parameters"]["properties"]
-        assert "ready" in props
-        assert props["ready"]["type"] == "boolean"
-
-    def test_schema_top_level_required(self):
-        """Test that top-level required fields are correct."""
-        required = FUNCTION_SCHEMA["function"]["parameters"]["required"]
-        assert "plan" in required
-        assert "steps" in required
-        assert "ready" in required
-
-    def test_schema_top_level_additional_properties(self):
-        """Test that additionalProperties is False at top level."""
-        params = FUNCTION_SCHEMA["function"]["parameters"]
-        assert params["additionalProperties"] is False
-
-
-class TestReasoningPlan:
-    """Tests for the ReasoningPlan model with structured steps."""
-
-    def test_reasoning_plan_with_empty_steps(self):
-        """Test ReasoningPlan can be created with empty steps."""
-        plan = ReasoningPlan(
-            plan="Simple plan",
-            steps=[],
-            ready=True,
-        )
-
-        assert plan.plan == "Simple plan"
-        assert plan.steps == []
-        assert plan.ready is True
-
-    def test_reasoning_plan_with_steps(self):
-        """Test ReasoningPlan with structured steps."""
-        steps = [
-            PlanStep(step_number=1, description="First step", tool_to_use="tool1"),
-            PlanStep(step_number=2, description="Second step", depends_on=[1]),
-        ]
-
-        plan = ReasoningPlan(
-            plan="Multi-step plan",
-            steps=steps,
-            ready=True,
-        )
-
-        assert plan.plan == "Multi-step plan"
-        assert len(plan.steps) == 2
-        assert plan.steps[0].step_number == 1
-        assert plan.steps[1].depends_on == [1]
-
-
-class TestAgentReasoningWithMockedLLM:
-    """Tests for AgentReasoning with mocked LLM responses."""
-
-    @pytest.fixture
-    def mock_agent(self):
-        """Create a mock agent for testing."""
-        agent = MagicMock()
-        agent.role = "Test Agent"
-        agent.goal = "Test goal"
-        agent.backstory = "Test backstory"
-        agent.verbose = False
-        agent.planning_config = PlanningConfig()
-        agent.i18n = MagicMock()
-        agent.i18n.retrieve.return_value = "Test prompt: {description}"
-        # Mock the llm attribute
-        agent.llm = MagicMock()
-        agent.llm.supports_function_calling.return_value = True
-        return agent
-
-    def test_parse_steps_from_function_response(self, mock_agent):
-        """Test that steps are correctly parsed from LLM function response."""
-        # Mock the LLM response with structured steps
-        mock_response = json.dumps({
-            "plan": "Research and analyze",
-            "steps": [
-                {
-                    "step_number": 1,
-                    "description": "Search for information",
-                    "tool_to_use": "search_tool",
-                    "depends_on": [],
-                },
-                {
-                    "step_number": 2,
-                    "description": "Analyze results",
-                    "tool_to_use": None,
-                    "depends_on": [1],
-                },
-            ],
-            "ready": True,
-        })
-
-        mock_agent.llm.call.return_value = mock_response
-
-        handler = AgentReasoning(
-            agent=mock_agent,
-            task=None,
-            description="Test task",
-            expected_output="Test output",
-        )
-
-        # Call the function parsing method
-        plan, steps, ready = handler._call_with_function(
-            prompt="Test prompt",
-            plan_type="create_plan",
-        )
-
-        assert plan == "Research and analyze"
-        assert len(steps) == 2
-        assert steps[0].step_number == 1
-        assert steps[0].tool_to_use == "search_tool"
-        assert steps[1].depends_on == [1]
-        assert ready is True
-
-    def test_parse_steps_handles_missing_optional_fields(self, mock_agent):
-        """Test that missing optional fields are handled correctly."""
-        mock_response = json.dumps({
-            "plan": "Simple plan",
-            "steps": [
-                {
-                    "step_number": 1,
-                    "description": "Do something",
-                    "tool_to_use": None,
-                    "depends_on": [],
-                },
-            ],
-            "ready": True,
-        })
-
-        mock_agent.llm.call.return_value = mock_response
-
-        handler = AgentReasoning(
-            agent=mock_agent,
-            task=None,
-            description="Test task",
-            expected_output="Test output",
-        )
-
-        plan, steps, ready = handler._call_with_function(
-            prompt="Test prompt",
-            plan_type="create_plan",
-        )
-
-        assert len(steps) == 1
-        assert steps[0].tool_to_use is None
-        assert steps[0].depends_on == []
-
-    def test_parse_steps_with_missing_fields_uses_defaults(self, mock_agent):
-        """Test that steps with missing fields get default values."""
-        mock_response = json.dumps({
-            "plan": "Plan with step missing fields",
-            "steps": [
-                {"step_number": 1, "description": "Valid step", "tool_to_use": None, "depends_on": []},
-                {"step_number": 2},  # Missing description, tool_to_use, depends_on
-                {"step_number": 3, "description": "Another valid", "tool_to_use": None, "depends_on": []},
-            ],
-            "ready": True,
-        })
-
-        mock_agent.llm.call.return_value = mock_response
-
-        handler = AgentReasoning(
-            agent=mock_agent,
-            task=None,
-            description="Test task",
-            expected_output="Test output",
-        )
-
-        plan, steps, ready = handler._call_with_function(
-            prompt="Test prompt",
-            plan_type="create_plan",
-        )
-
-        # All 3 steps should be parsed, with defaults for missing fields
-        assert len(steps) == 3
-        assert steps[0].step_number == 1
-        assert steps[0].description == "Valid step"
-        assert steps[1].step_number == 2
-        assert steps[1].description == ""  # Default value
-        assert steps[2].step_number == 3
-
-
-class TestTodoCreationFromPlan:
-    """Tests for converting plan steps to todo items."""
-
-    def test_create_todos_from_plan_steps(self):
-        """Test creating TodoList from PlanSteps."""
-        steps = [
-            PlanStep(
-                step_number=1,
-                description="Research competitors",
-                tool_to_use="search_tool",
-                depends_on=[],
-            ),
-            PlanStep(
-                step_number=2,
-                description="Analyze data",
-                tool_to_use=None,
-                depends_on=[1],
-            ),
-            PlanStep(
-                step_number=3,
-                description="Generate report",
-                tool_to_use="write_tool",
-                depends_on=[1, 2],
-            ),
-        ]
-
-        # Convert steps to todos (mirroring agent_executor._create_todos_from_plan)
-        todos = []
-        for step in steps:
-            todo = TodoItem(
-                step_number=step.step_number,
-                description=step.description,
-                tool_to_use=step.tool_to_use,
-                depends_on=step.depends_on,
-                status="pending",
-            )
-            todos.append(todo)
-
-        todo_list = TodoList(items=todos)
-
-        assert len(todo_list.items) == 3
-        assert todo_list.pending_count == 3
-        assert todo_list.completed_count == 0
-
-        # Verify todo properties match step properties
-        assert todo_list.items[0].description == "Research competitors"
-        assert todo_list.items[0].tool_to_use == "search_tool"
-        assert todo_list.items[1].depends_on == [1]
-        assert todo_list.items[2].depends_on == [1, 2]
-
-
-# =============================================================================
-# Provider-Specific Integration Tests (VCR recorded)
-# =============================================================================
-
-
-# Common test tools used across provider tests
-def create_research_tools():
-    """Create research tools for testing structured planning."""
-    from crewai.tools import tool
-
-    @tool
-    def web_search(query: str) -> str:
-        """Search the web for information on a given topic.
-
-        Args:
-            query: The search query to look up.
-
-        Returns:
-            Search results as a string.
-        """
-        # Simulated search results for testing
-        return f"Search results for '{query}': Found 3 relevant articles about the topic including market analysis, competitor data, and industry trends."
-
-    @tool
-    def read_website(url: str) -> str:
-        """Read and extract content from a website URL.
-
-        Args:
-            url: The URL of the website to read.
-
-        Returns:
-            The extracted content from the website.
-        """
-        # Simulated website content for testing
-        return f"Content from {url}: This article discusses key insights about the topic including market size ($50B), growth rate (15% YoY), and major players in the industry."
-
-    @tool
-    def generate_report(title: str, findings: str) -> str:
-        """Generate a structured report based on research findings.
-
-        Args:
-            title: The title of the report.
-            findings: The research findings to include.
-
-        Returns:
-            A formatted report string.
-        """
-        return f"# {title}\n\n## Executive Summary\n{findings}\n\n## Conclusion\nBased on the analysis, the market shows strong growth potential."
-
-    return web_search, read_website, generate_report
-
-
-RESEARCH_TASK = """Research the current state of the AI agent market:
-1. Search for recent information about AI agents and their market trends
-2. Read detailed content from a relevant industry source
-3. Generate a brief report summarizing the key findings
-
-Use the available tools for each step."""
-
-
-class TestOpenAIStructuredPlanning:
-    """Integration tests for OpenAI structured planning with research workflow."""
-
-    @pytest.mark.vcr()
-    def test_openai_research_workflow_generates_steps(self):
-        """Test that OpenAI generates structured plan steps for a research task."""
-        web_search, read_website, generate_report = create_research_tools()
-        llm = LLM(model="gpt-4o")
-
-        agent = Agent(
-            role="Research Analyst",
-            goal="Conduct thorough research and produce insightful reports",
-            backstory="An experienced analyst skilled at gathering information and synthesizing findings into actionable insights.",
-            llm=llm,
-            tools=[web_search, read_website, generate_report],
-            planning_config=PlanningConfig(max_attempts=1),
-            verbose=False,
-        )
-
-        result = agent.kickoff(RESEARCH_TASK)
-
-        # Verify result exists
-        assert result is not None
-        assert result.raw is not None
-        # The result should contain some report-like content
-        assert len(str(result.raw)) > 50
-
-
-class TestAnthropicStructuredPlanning:
-    """Integration tests for Anthropic structured planning with research workflow."""
-
-    @pytest.fixture(autouse=True)
-    def mock_anthropic_api_key(self):
-        """Mock API key if not set."""
-        if "ANTHROPIC_API_KEY" not in os.environ:
-            with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "test-key"}):
-                yield
-        else:
-            yield
-
-    @pytest.mark.vcr()
-    def test_anthropic_research_workflow_generates_steps(self):
-        """Test that Anthropic generates structured plan steps for a research task."""
-        web_search, read_website, generate_report = create_research_tools()
-        llm = LLM(model="anthropic/claude-sonnet-4-20250514")
-
-        agent = Agent(
-            role="Research Analyst",
-            goal="Conduct thorough research and produce insightful reports",
-            backstory="An experienced analyst skilled at gathering information and synthesizing findings into actionable insights.",
-            llm=llm,
-            tools=[web_search, read_website, generate_report],
-            planning_config=PlanningConfig(max_attempts=1),
-            verbose=False,
-        )
-
-        result = agent.kickoff(RESEARCH_TASK)
-
-        # Verify result exists
-        assert result is not None
-        assert result.raw is not None
-        # The result should contain some report-like content
-        assert len(str(result.raw)) > 50
-
-
-class TestGeminiStructuredPlanning:
-    """Integration tests for Google Gemini structured planning with research workflow."""
-
-    @pytest.fixture(autouse=True)
-    def mock_google_api_key(self):
-        """Mock API key if not set."""
-        if "GOOGLE_API_KEY" not in os.environ and "GEMINI_API_KEY" not in os.environ:
-            with patch.dict(os.environ, {"GOOGLE_API_KEY": "test-key"}):
-                yield
-        else:
-            yield
-
-    @pytest.mark.vcr()
-    def test_gemini_research_workflow_generates_steps(self):
-        """Test that Gemini generates structured plan steps for a research task."""
-        web_search, read_website, generate_report = create_research_tools()
-        llm = LLM(model="gemini/gemini-2.5-flash")
-
-        agent = Agent(
-            role="Research Analyst",
-            goal="Conduct thorough research and produce insightful reports",
-            backstory="An experienced analyst skilled at gathering information and synthesizing findings into actionable insights.",
-            llm=llm,
-            tools=[web_search, read_website, generate_report],
-            planning_config=PlanningConfig(max_attempts=1),
-            verbose=False,
-        )
-
-        result = agent.kickoff(RESEARCH_TASK)
-
-        # Verify result exists
-        assert result is not None
-        assert result.raw is not None
-        # The result should contain some report-like content
-        assert len(str(result.raw)) > 50
-
-
-class TestAzureStructuredPlanning:
-    """Integration tests for Azure OpenAI structured planning with research workflow."""
-
-    @pytest.fixture(autouse=True)
-    def mock_azure_credentials(self):
-        """Mock Azure credentials for tests."""
-        if "AZURE_API_KEY" not in os.environ:
-            with patch.dict(os.environ, {
-                "AZURE_API_KEY": "test-key",
-                "AZURE_ENDPOINT": "https://test.openai.azure.com"
-            }):
-                yield
-        else:
-            yield
-
-    @pytest.mark.vcr()
-    def test_azure_research_workflow_generates_steps(self):
-        """Test that Azure OpenAI generates structured plan steps for a research task."""
-        web_search, read_website, generate_report = create_research_tools()
-        llm = LLM(model="azure/gpt-4o")
-
-        agent = Agent(
-            role="Research Analyst",
-            goal="Conduct thorough research and produce insightful reports",
-            backstory="An experienced analyst skilled at gathering information and synthesizing findings into actionable insights.",
-            llm=llm,
-            tools=[web_search, read_website, generate_report],
-            planning_config=PlanningConfig(max_attempts=1),
-            verbose=False,
-        )
-
-        result = agent.kickoff(RESEARCH_TASK)
-
-        # Verify result exists
-        assert result is not None
-        assert result.raw is not None
-        # The result should contain some report-like content
-        assert len(str(result.raw)) > 50
-
-
-# =============================================================================
-# Unit Tests with Mocked LLM Providers
-# =============================================================================
-
-
-class TestStructuredPlanningWithMockedProviders:
-    """Unit tests with mocked LLM providers for faster execution."""
-
-    def _create_mock_plan_response(self, steps_data):
-        """Helper to create mock plan response."""
-        return json.dumps({
-            "plan": "Test plan",
-            "steps": steps_data,
-            "ready": True,
-        })
-
-    def test_openai_mock_structured_response(self):
-        """Test parsing OpenAI structured response."""
-        steps_data = [
-            {"step_number": 1, "description": "Search", "tool_to_use": "search", "depends_on": []},
-            {"step_number": 2, "description": "Analyze", "tool_to_use": None, "depends_on": [1]},
-        ]
-
-        response = self._create_mock_plan_response(steps_data)
-        parsed = json.loads(response)
-
-        assert len(parsed["steps"]) == 2
-        assert parsed["steps"][0]["tool_to_use"] == "search"
-        assert parsed["steps"][1]["depends_on"] == [1]
-
-    def test_anthropic_mock_structured_response(self):
-        """Test parsing Anthropic structured response (same format)."""
-        steps_data = [
-            {"step_number": 1, "description": "Research", "tool_to_use": "web_search", "depends_on": []},
-            {"step_number": 2, "description": "Summarize", "tool_to_use": None, "depends_on": [1]},
-            {"step_number": 3, "description": "Report", "tool_to_use": "write_file", "depends_on": [1, 2]},
-        ]
-
-        response = self._create_mock_plan_response(steps_data)
-        parsed = json.loads(response)
-
-        assert len(parsed["steps"]) == 3
-        assert parsed["steps"][2]["depends_on"] == [1, 2]
-
-    def test_gemini_mock_structured_response(self):
-        """Test parsing Gemini structured response (same format)."""
-        steps_data = [
-            {"step_number": 1, "description": "Gather data", "tool_to_use": "data_tool", "depends_on": []},
-            {"step_number": 2, "description": "Process", "tool_to_use": None, "depends_on": [1]},
-        ]
-
-        response = self._create_mock_plan_response(steps_data)
-        parsed = json.loads(response)
-
-        assert len(parsed["steps"]) == 2
-        assert parsed["ready"] is True
-
-    def test_azure_mock_structured_response(self):
-        """Test parsing Azure OpenAI structured response (same format as OpenAI)."""
-        steps_data = [
-            {"step_number": 1, "description": "Initialize", "tool_to_use": None, "depends_on": []},
-            {"step_number": 2, "description": "Execute", "tool_to_use": "executor", "depends_on": [1]},
-            {"step_number": 3, "description": "Finalize", "tool_to_use": None, "depends_on": [1, 2]},
-        ]
-
-        response = self._create_mock_plan_response(steps_data)
-        parsed = json.loads(response)
-
-        assert len(parsed["steps"]) == 3
-        assert parsed["steps"][0]["tool_to_use"] is None
-
-
-class TestTodoListIntegration:
-    """Integration tests for TodoList with plan execution simulation."""
-
-    def test_full_plan_execution_workflow(self):
-        """Test complete workflow from plan to todos to execution."""
-        # Simulate plan steps from LLM
-        plan_steps = [
-            PlanStep(
-                step_number=1,
-                description="Research the topic",
-                tool_to_use="search_tool",
-                depends_on=[],
-            ),
-            PlanStep(
-                step_number=2,
-                description="Compile findings",
-                tool_to_use=None,
-                depends_on=[1],
-            ),
-            PlanStep(
-                step_number=3,
-                description="Generate summary",
-                tool_to_use="summarize_tool",
-                depends_on=[1, 2],
-            ),
-        ]
-
-        # Convert to todos (like agent_executor._create_todos_from_plan)
-        todos = [
-            TodoItem(
-                step_number=step.step_number,
-                description=step.description,
-                tool_to_use=step.tool_to_use,
-                depends_on=step.depends_on,
-                status="pending",
-            )
-            for step in plan_steps
-        ]
-        todo_list = TodoList(items=todos)
-
-        # Verify initial state
-        assert todo_list.pending_count == 3
-        assert todo_list.is_complete is False
-
-        # Simulate execution
-        for i in range(1, 4):
-            todo_list.mark_running(i)
-            assert todo_list.current_todo.step_number == i
-            todo_list.mark_completed(i, result=f"Step {i} completed")
-
-        # Verify final state
-        assert todo_list.is_complete is True
-        assert todo_list.completed_count == 3
-        assert all(item.result is not None for item in todo_list.items)
-
-    def test_dependency_aware_execution(self):
-        """Test that dependencies are respected in execution order."""
-        steps = [
-            PlanStep(step_number=1, description="Base step", depends_on=[]),
-            PlanStep(step_number=2, description="Depends on 1", depends_on=[1]),
-            PlanStep(step_number=3, description="Depends on 1", depends_on=[1]),
-            PlanStep(step_number=4, description="Depends on 2 and 3", depends_on=[2, 3]),
-        ]
-
-        todos = [
-            TodoItem(
-                step_number=s.step_number,
-                description=s.description,
-                depends_on=s.depends_on,
-            )
-            for s in steps
-        ]
-        todo_list = TodoList(items=todos)
-
-        # Helper to check if dependencies are satisfied
-        def can_execute(todo: TodoItem) -> bool:
-            for dep in todo.depends_on:
-                dep_todo = todo_list.get_by_step_number(dep)
-                if dep_todo and dep_todo.status != "completed":
-                    return False
-            return True
-
-        # Step 1 has no dependencies
-        assert can_execute(todo_list.items[0]) is True
-
-        # Steps 2 and 3 depend on 1 (not yet done)
-        assert can_execute(todo_list.items[1]) is False
-        assert can_execute(todo_list.items[2]) is False
-
-        # Complete step 1
-        todo_list.mark_completed(1)
-
-        # Now steps 2 and 3 can execute
-        assert can_execute(todo_list.items[1]) is True
-        assert can_execute(todo_list.items[2]) is True
-
-        # Step 4 still can't (depends on 2 and 3)
-        assert can_execute(todo_list.items[3]) is False
-
-        # Complete steps 2 and 3
-        todo_list.mark_completed(2)
-        todo_list.mark_completed(3)
-
-        # Now step 4 can execute
-        assert can_execute(todo_list.items[3]) is True

lib/devtools/src/crewai_devtools/__init__.py

@@ -1,3 +1,3 @@
 """CrewAI development tools."""
 
-__version__ = "1.10.1"
+__version__ = "1.10.1a"

lib/devtools/src/crewai_devtools/cli.py

@@ -200,7 +200,7 @@ def add_docs_version(docs_json_path: Path, version: str) -> bool:
 
     Args:
         docs_json_path: Path to docs/docs.json.
-        version: Version string (e.g., "1.10.1b1").
+        version: Version string (e.g., "1.10.1a").
 
     Returns:
         True if docs.json was updated, False otherwise.

pyproject.toml

@@ -8,9 +8,9 @@ authors = [
 
 [dependency-groups]
 dev = [
-    "ruff==0.15.1",
-    "mypy==1.19.1",
-    "pre-commit==4.5.1",
+    "ruff==0.14.7",
+    "mypy==1.19.0",
+    "pre-commit==4.5.0",
     "bandit==1.9.2",
     "pytest==8.4.2",
     "pytest-asyncio==1.3.0",
@@ -23,9 +23,9 @@ dev = [
     "pytest-split==0.10.0",
     "types-requests~=2.31.0.6",
     "types-pyyaml==6.0.*",
-    "types-regex==2026.1.15.*",
+    "types-regex==2024.11.6.*",
     "types-appdirs==1.4.*",
-    "boto3-stubs[bedrock-runtime]==1.42.40",
+    "boto3-stubs[bedrock-runtime]==1.40.54",
     "types-psycopg2==2.9.21.20251012",
     "types-pymysql==1.1.0.20250916",
     "types-aiofiles~=25.1.0",
@@ -146,14 +146,9 @@ python_functions = "test_*"
 
 # composio-core pins rich<14 but textual requires rich>=14.
 # onnxruntime 1.24+ dropped Python 3.10 wheels; cap it so qdrant[fastembed] resolves on 3.10.
-# fastembed 0.7.x and docling 2.63 cap pillow<12; the removed APIs don't affect them.
-# langchain-core 0.3.76 has a template-injection vuln (GHSA); force >=0.3.80.
 override-dependencies = [
     "rich>=13.7.1",
     "onnxruntime<1.24; python_version < '3.11'",
-    "pillow>=12.1.1",
-    "langchain-core>=0.3.80,<1",
-    "urllib3>=2.6.3",
 ]
 
 [tool.uv.workspace]

uv.lock

@@ -20,19 +20,16 @@ members = [
     "crewai-tools",
 ]
 overrides = [
-    { name = "langchain-core", specifier = ">=0.3.80,<1" },
     { name = "onnxruntime", marker = "python_full_version < '3.11'", specifier = "<1.24" },
-    { name = "pillow", specifier = ">=12.1.1" },
     { name = "rich", specifier = ">=13.7.1" },
-    { name = "urllib3", specifier = ">=2.6.3" },
 ]
 
 [manifest.dependency-groups]
 dev = [
     { name = "bandit", specifier = "==1.9.2" },
-    { name = "boto3-stubs", extras = ["bedrock-runtime"], specifier = "==1.42.40" },
-    { name = "mypy", specifier = "==1.19.1" },
-    { name = "pre-commit", specifier = "==4.5.1" },
+    { name = "boto3-stubs", extras = ["bedrock-runtime"], specifier = "==1.40.54" },
+    { name = "mypy", specifier = "==1.19.0" },
+    { name = "pre-commit", specifier = "==4.5.0" },
     { name = "pytest", specifier = "==8.4.2" },
     { name = "pytest-asyncio", specifier = "==1.3.0" },
     { name = "pytest-randomly", specifier = "==4.0.1" },
@@ -41,13 +38,13 @@ dev = [
     { name = "pytest-subprocess", specifier = "==1.5.3" },
     { name = "pytest-timeout", specifier = "==2.4.0" },
     { name = "pytest-xdist", specifier = "==3.8.0" },
-    { name = "ruff", specifier = "==0.15.1" },
+    { name = "ruff", specifier = "==0.14.7" },
     { name = "types-aiofiles", specifier = "~=25.1.0" },
     { name = "types-appdirs", specifier = "==1.4.*" },
     { name = "types-psycopg2", specifier = "==2.9.21.20251012" },
     { name = "types-pymysql", specifier = "==1.1.0.20250916" },
     { name = "types-pyyaml", specifier = "==6.0.*" },
-    { name = "types-regex", specifier = "==2026.1.15.*" },
+    { name = "types-regex", specifier = "==2024.11.6.*" },
     { name = "types-requests", specifier = "~=2.31.0.6" },
     { name = "vcrpy", specifier = "==7.0.0" },
 ]
@@ -596,7 +593,8 @@ dependencies = [
     { name = "pydantic" },
     { name = "starlette" },
     { name = "typing-extensions" },
-    { name = "urllib3" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
     { name = "uvicorn" },
     { name = "websockets" },
 ]
@@ -621,16 +619,16 @@ wheels = [
 
 [[package]]
 name = "boto3-stubs"
-version = "1.42.40"
+version = "1.40.54"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "botocore-stubs" },
     { name = "types-s3transfer" },
     { name = "typing-extensions", marker = "python_full_version < '3.12'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/89/87/190df0854bcacc31d58dab28721f855d928ddd1d20c0ca2c201731d4622b/boto3_stubs-1.42.40.tar.gz", hash = "sha256:2689e235ae0deb6878fced175f7c2701fd8c088e6764de65e8c14085c1fc1914", size = 100886, upload-time = "2026-02-02T23:19:28.917Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e2/70/245477b7f07c9e1533c47fa69e611b172814423a6fd4637004f0d2a13b73/boto3_stubs-1.40.54.tar.gz", hash = "sha256:e21a9eda979a451935eb3196de3efbe15b9470e6bf9027406d1f6d0ac08b339e", size = 100919, upload-time = "2025-10-16T19:49:17.079Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e7/09/e1d031ceae85688c13dd16d84a0e6e416def62c6b23e04f7d318837ee355/boto3_stubs-1.42.40-py3-none-any.whl", hash = "sha256:66679f1075e094b15b2032d8cfc4f070a472e066b04ee1edf61aa44884a6d2cd", size = 69782, upload-time = "2026-02-02T23:19:20.16Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/52/ee9dadd1cc8911e16f18ca9fa036a10328e0a0d3fddd54fadcc1ca0f9143/boto3_stubs-1.40.54-py3-none-any.whl", hash = "sha256:548a4786785ba7b43ef4ef1a2a764bebbb0301525f3201091fcf412e4c8ce323", size = 69712, upload-time = "2025-10-16T19:49:12.847Z" },
 ]
 
 [package.optional-dependencies]
@@ -645,7 +643,8 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jmespath" },
     { name = "python-dateutil" },
-    { name = "urllib3" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/35/c1/8c4c199ae1663feee579a15861e34f10b29da11ae6ea0ad7b6a847ef3823/botocore-1.40.70.tar.gz", hash = "sha256:61b1f2cecd54d1b28a081116fa113b97bf4e17da57c62ae2c2751fe4c528af1f", size = 14444592, upload-time = "2025-11-10T20:29:04.046Z" }
 wheels = [
@@ -1195,8 +1194,8 @@ requires-dist = [
     { name = "click", specifier = "~=8.1.7" },
     { name = "crewai-files", marker = "extra == 'file-processing'", editable = "lib/crewai-files" },
     { name = "crewai-tools", marker = "extra == 'tools'", editable = "lib/crewai-tools" },
-    { name = "docling", marker = "extra == 'docling'", specifier = "~=2.75.0" },
-    { name = "google-genai", marker = "extra == 'google-genai'", specifier = "~=1.65.0" },
+    { name = "docling", marker = "extra == 'docling'", specifier = "~=2.63.0" },
+    { name = "google-genai", marker = "extra == 'google-genai'", specifier = "~=1.49.0" },
     { name = "httpx", specifier = "~=0.28.1" },
     { name = "httpx-auth", marker = "extra == 'a2a'", specifier = "~=0.23.1" },
     { name = "httpx-sse", marker = "extra == 'a2a'", specifier = "~=0.4.0" },
@@ -1226,7 +1225,7 @@ requires-dist = [
     { name = "regex", specifier = "~=2026.1.15" },
     { name = "textual", specifier = ">=7.5.0" },
     { name = "tiktoken", marker = "extra == 'embeddings'", specifier = "~=0.8.0" },
-    { name = "tokenizers", specifier = ">=0.21,<1" },
+    { name = "tokenizers", specifier = "~=0.20.3" },
     { name = "tomli", specifier = "~=2.0.2" },
     { name = "tomli-w", specifier = "~=1.1.0" },
     { name = "uv", specifier = "~=0.9.13" },
@@ -1274,8 +1273,8 @@ requires-dist = [
     { name = "aiocache", specifier = "~=0.12.3" },
     { name = "aiofiles", specifier = "~=24.1.0" },
     { name = "av", specifier = "~=13.0.0" },
-    { name = "pillow", specifier = "~=12.1.1" },
-    { name = "pypdf", specifier = "~=6.7.5" },
+    { name = "pillow", specifier = "~=10.4.0" },
+    { name = "pypdf", specifier = "~=4.0.0" },
     { name = "python-magic", specifier = ">=0.4.27" },
     { name = "tinytag", specifier = "~=1.10.0" },
 ]
@@ -1667,7 +1666,8 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pywin32", marker = "sys_platform == 'win32'" },
     { name = "requests" },
-    { name = "urllib3" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/91/9b/4a2ea29aeba62471211598dac5d96825bb49348fa07e906ea930394a83ce/docker-7.1.0.tar.gz", hash = "sha256:ad8c70e6e3f8926cb8a92619b832b4ea5299e2831c14284663184e200546fa6c", size = 117834, upload-time = "2024-05-23T11:13:57.216Z" }
 wheels = [
@@ -1676,13 +1676,12 @@ wheels = [
 
 [[package]]
 name = "docling"
-version = "2.75.0"
+version = "2.63.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "accelerate" },
     { name = "beautifulsoup4" },
     { name = "certifi" },
-    { name = "defusedxml" },
     { name = "docling-core", extra = ["chunking"] },
     { name = "docling-ibm-models" },
     { name = "docling-parse" },
@@ -1709,17 +1708,16 @@ dependencies = [
     { name = "tqdm" },
     { name = "typer" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/77/0b/8ea363fd3c8bb4facb8d3c37aebfe7ad5265fecc1c6bd40f979d1f6179ba/docling-2.75.0.tar.gz", hash = "sha256:1b0a77766e201e5e2d118e236c006f3814afcea2e13726fb3c7389d666a56622", size = 364929, upload-time = "2026-02-24T20:18:04.896Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/c4/a8b7c66f0902ed4d0bcd87db94d3929539ac5fdff5325978744b30bee6b1/docling-2.63.0.tar.gz", hash = "sha256:5592c25e986ebf58811bcbfdbc8217d1a2074638b5412364968a1f1482994cc8", size = 250895, upload-time = "2025-11-20T14:43:53.131Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b8/85/5c6885547ce5cde33af43201e3b2b04cf2360e6854abc07485f54b8d265d/docling-2.75.0-py3-none-any.whl", hash = "sha256:6e156f0326edb6471fc076e978ac64f902f54aac0da13cf89df456013e377bcc", size = 396243, upload-time = "2026-02-24T20:18:03.57Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fd/e5d23f8f12e18a8ada7d977cb86ae5f964b827ae71a42e3ee9f9e2d7d577/docling-2.63.0-py3-none-any.whl", hash = "sha256:59f39b6cf43f10f8c9e429c90f6973245c4c3752d5a03ca3e1732f6fb2905000", size = 268323, upload-time = "2025-11-20T14:43:51.823Z" },
 ]
 
 [[package]]
 name = "docling-core"
-version = "2.66.0"
+version = "2.63.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "defusedxml" },
     { name = "jsonref" },
     { name = "jsonschema" },
     { name = "latex2mathml" },
@@ -1731,9 +1729,9 @@ dependencies = [
     { name = "typer" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/00/ba/0b40f5bb2fff918bea79b0ea843ab3479a5f2c7a4be7009ddd713f0e8ab0/docling_core-2.66.0.tar.gz", hash = "sha256:3bbb85bf3e0106d20e7f3d2801ec40460347c95bcda55862b1fcb9effa4f78ea", size = 256592, upload-time = "2026-02-26T10:46:56.744Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/76/f6a1333c0ce4c20e60358185ff8b7fa92e1e1561a43a6788e7c8aaa9898e/docling_core-2.63.0.tar.gz", hash = "sha256:946cf97f27cb81a2c6507121045a356be91e40b5a06bbaf028ca7036df78b2f1", size = 251016, upload-time = "2026-02-03T14:41:07.158Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/df/6983118cb33e5ce166592945bb473a2b7c60865a9ba661c1d462cfd2c356/docling_core-2.66.0-py3-none-any.whl", hash = "sha256:5f6cf447ca4f50c27531bd15ea1d16c3a811fbfe22e0107207711561520fb316", size = 241133, upload-time = "2026-02-26T10:46:55.021Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/c4/0c825b46412f088828dd2730d231c745d1ff4b5537eed292e827103eff37/docling_core-2.63.0-py3-none-any.whl", hash = "sha256:8f39167bf17da13225c8a67d23df98c87a74e2ab39762dbf51fab93d9b90de25", size = 238637, upload-time = "2026-02-03T14:41:05.55Z" },
 ]
 
 [package.optional-dependencies]
@@ -1773,7 +1771,7 @@ wheels = [
 
 [[package]]
 name = "docling-parse"
-version = "5.4.0"
+version = "4.7.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "docling-core" },
@@ -1782,24 +1780,25 @@ dependencies = [
     { name = "pywin32", marker = "sys_platform == 'win32'" },
     { name = "tabulate" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5c/23/07335df49075c376f1cb1238438234a41989688b70119064ef5b9cf1731e/docling_parse-5.4.0.tar.gz", hash = "sha256:1c48096b21cd23d1ab1d306bf0fdfbc7626ec22d62c51eb08a9ec49a5b58dbc8", size = 55466941, upload-time = "2026-02-24T11:46:56.627Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/bb/7a/653c3b11920113217724fab9b4740f9f8964864f92a2a27590accecec5ac/docling_parse-4.7.3.tar.gz", hash = "sha256:5936e6bcb7969c2a13f38ecc75cada3b0919422dc845e96da4b0b7b3bbc394ce", size = 67646746, upload-time = "2026-01-14T14:18:19.376Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/99/7c6c2a444d7e6f16b8628b3b71c6501b9b51bf8e987b07a7f60034763fce/docling_parse-5.4.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:b8c48d0fa52cdcd86dd2422ea78da55c99381d6c8ff8bd6abf9cb5f971654c57", size = 7764250, upload-time = "2026-02-24T11:46:18.402Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/86/acc1a6bf3c58ec2ffb2aef5076f04d69c6c9639818d4ffb6d5dfc8bf58b3/docling_parse-5.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2efe3e8748e450c47cff1715db4d3ed4e291212e251a7a6b7d9549090f3a1e6c", size = 8214211, upload-time = "2026-02-24T11:46:20.313Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/b1/c057ef6c61df8bbc81e7f2f860a65fca37bd0393c9a11fb387fd8f1e54db/docling_parse-5.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4b7d7bb0816708a87113e1c28b47ff3951eebc927e295275c70b4651090c04c", size = 8270981, upload-time = "2026-02-24T11:46:21.929Z" },
-    { url = "https://files.pythonhosted.org/packages/38/3f/08dcd0e68c906865a9453aad3a551de23e0743a65d57248445d1244026b9/docling_parse-5.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:57a2c6133c859358cde26c1feb86c748749473544c01f938c987c1a007588c82", size = 9169554, upload-time = "2026-02-24T11:46:24.417Z" },
-    { url = "https://files.pythonhosted.org/packages/45/85/bfd7f13d6a787bf2033e082aea26ba8a05e809ef1f72e6761403477e1d3f/docling_parse-5.4.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:e0e330c370c66aa6263b0537e756a05a5ee9c6c0ea8453dca6c6a95bc6549c47", size = 7764928, upload-time = "2026-02-24T11:46:26.515Z" },
-    { url = "https://files.pythonhosted.org/packages/02/b4/4390ecd7ed34678c2890a5b40b480f43568775bf3446d5a65a5b81241c15/docling_parse-5.4.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c3b5692dbb2fa20169e54452a7889de246e45a2d74b446c00bc0bea8487e859", size = 8168543, upload-time = "2026-02-24T11:46:28.168Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/94/bcc469b966be6cb03c6b6aa7989549c00a320575eb5b20ff1f52bada5297/docling_parse-5.4.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d6fed073157e3a3373512c4fd2866081e71dc510a66a8ed303c2b004bc6ff0a", size = 8262410, upload-time = "2026-02-24T11:46:30.027Z" },
-    { url = "https://files.pythonhosted.org/packages/15/9b/1419c9481ac71bb1d23b0bd4b72a991e5b03c7d3c4ec3c3078fb2e9f2be2/docling_parse-5.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:1573341070f81d5553840ade17895e8864aef8f3a0161034302fdab8e172c11c", size = 9170756, upload-time = "2026-02-24T11:46:31.719Z" },
-    { url = "https://files.pythonhosted.org/packages/70/55/a4d5ede8ad11da359ee48d8d17ac77fb4ae59c3d275f50d1f9bc5cdf9b3a/docling_parse-5.4.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3bf45ef2a9bf3ea86b7033f0337927568147dfb6f2c2828ef353d66ebc17eb49", size = 7766010, upload-time = "2026-02-24T11:46:33.592Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/ac/87308a424022559ea88d1765a3c3d2746c1286f22a2eb3606165c17518d6/docling_parse-5.4.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a77401b3e1b68e2965e9cc25f3907c6c1198b988098983cf726109265ad4317f", size = 8166965, upload-time = "2026-02-24T11:46:35.108Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/18/12b49c87109f63ff54e570edd2faa47d1193ecf4b8e94ff5d273645f879e/docling_parse-5.4.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a4bd77a7abfe1843e4d8cedcfb4363b4975227af7622f2ded3a0fc2ce7bd0b4", size = 8261576, upload-time = "2026-02-24T11:46:36.927Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/c3/862ddb3ece951f467384d58e503394589e9428488fa956fe399d2b1738c1/docling_parse-5.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:88e27d43101e71f56f22594ce1b05d5a3a868df7ee16f2dd167214735f12636f", size = 9172236, upload-time = "2026-02-24T11:46:38.423Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/54/a6876b41387ac11967c161d85ad06db1d562856add11d633afc24c788885/docling_parse-5.4.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:dda35a980afb3afbf432f4781fed507928188e27b40884226d720f4b3a9afa9c", size = 7766085, upload-time = "2026-02-24T11:46:40.351Z" },
-    { url = "https://files.pythonhosted.org/packages/72/fb/9f0d60af63b0f3063cbcae4273e527a14274d2e4b814f5c2051f8f16d55b/docling_parse-5.4.0-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b679653d1aadce962d3266b727c1563ae9aff3abf3a820d45b130a1a55bad2d2", size = 8167008, upload-time = "2026-02-24T11:46:42.459Z" },
-    { url = "https://files.pythonhosted.org/packages/61/28/d81815c3e4e4fe673bf4218e5e93b28c163a0200f8f802b963e9ea210192/docling_parse-5.4.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:86cede05b6ccb63c1685fbdc5bd16c5332c78c5dd9ea7565fd6f7f91c816ebae", size = 8261911, upload-time = "2026-02-24T11:46:44.234Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/63/ca87d27610fa04d9bc321f9253fc688ef751dc27a942fa531c3457947cc0/docling_parse-5.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:549b9bada8df48496e77e6ddf8a45a9c6cd5794d87c0b0e32f89fec108bb7b30", size = 9172252, upload-time = "2026-02-24T11:46:45.736Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/21/98decb689c173763f9a089e221c68b36d7b67ace0759f8eb2c9ca4b98dd5/docling_parse-4.7.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:65e0653d9617d38e73bab069dc3e7960668ff4a6b0ff45a7635c3790eeed8a08", size = 14614450, upload-time = "2026-01-14T14:17:21.626Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/88/c7642d019b6932b294ac3aae0208b2998fc0b7690473d12b1aa56636c99f/docling_parse-4.7.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:978e7e7032760385264896871ae87cb3a04081766cc966c57e9750ce803162ac", size = 15063165, upload-time = "2026-01-14T14:17:24.337Z" },
+    { url = "https://files.pythonhosted.org/packages/df/3d/a169dd9de8ed5f8edae2bbfd6528306ece67994813224bb0da7a6f694a5f/docling_parse-4.7.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1790e7e4ae202d67875c1c48fd6f8ef5c51d10b0c23157e4989b8673f2f31308", size = 15136333, upload-time = "2026-01-14T14:17:26.21Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b5/b600c4a040f57b7876878550551a8a92000ffedc58f716c384e1a09ec085/docling_parse-4.7.3-cp310-cp310-win_amd64.whl", hash = "sha256:5fc8f4770f9f6f90ba25f52451864a64394ddb158aea3a8fdda46a208c029cf6", size = 16144041, upload-time = "2026-01-14T14:17:28.108Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/81/dd317e0bce475153dc08a60a9a8615b1a04d4d3c9803175e6cb7b7e9b49b/docling_parse-4.7.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:66896bbe925073e4d48f18ec29dcd611a390d6b2378fae72125e77b020cd5664", size = 14615974, upload-time = "2026-01-14T14:17:30.246Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b5/088590e0b32fd0a393ca419c644d1435a1c99fa6b2a87888eef4d0fdea33/docling_parse-4.7.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:281347b3e937c1a5ffa6f8774ee603b64a0899fe8a6885573dec7eb48a3421d8", size = 14981051, upload-time = "2026-01-14T14:17:32.426Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/63/2b6c9127924487573d5419d58ec77955f0b7c0a923c8232ad461d71039aa/docling_parse-4.7.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3d86c51f9ce35a1b40b2f410f7271d9bd5fc58e7240f4cae7fdd2cef757e671", size = 15092586, upload-time = "2026-01-14T14:17:34.634Z" },
+    { url = "https://files.pythonhosted.org/packages/af/89/ed27a83eb113bdf0b0f82f3c30a0db3c005df58b236f6487b232dacdb57a/docling_parse-4.7.3-cp311-cp311-win_amd64.whl", hash = "sha256:3b04459cc97a8a4929622e341b9981e23987a63af07db599afc5e1c4d389060b", size = 16144866, upload-time = "2026-01-14T14:17:36.742Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/26/9d86ae12699a25b7233f76ce062253e9c14e57781e00166b792b3a9d56db/docling_parse-4.7.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:d89231aa4fba3e38b80c11beb8edc07569e934c1f3935b51f57904fefe958ba5", size = 14616739, upload-time = "2026-01-14T14:17:38.567Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/fd/1aebb8a7f15d658f3be858ddbbc4ef7206089d540a7df0dcd4b846b99901/docling_parse-4.7.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dffd19ed373b0da5cea124606b183489a8686c3d18643e94485be1bdda5713ea", size = 14980782, upload-time = "2026-01-14T14:17:40.659Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/47/a722527c9f89c65f69f8a463be4f12ad73bae18132f29d8de8b2d9f6f082/docling_parse-4.7.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc32b6f25a673e41b9a8112b6b841284f60dbac9427b7848a03b435460f74aee", size = 15092450, upload-time = "2026-01-14T14:17:42.838Z" },
+    { url = "https://files.pythonhosted.org/packages/91/c7/316373a92ba42c2aeaee128fc77a34333449fe3e820b9d524e0ee396ea35/docling_parse-4.7.3-cp312-cp312-win_amd64.whl", hash = "sha256:ef691045623863624f2cb7347572d0262a53cb84940ef7dd851d9f13a2eb8833", size = 16147359, upload-time = "2026-01-14T14:17:44.906Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/9f/b62390c85f99436fd0c40cfcdfea2b553482696ca735e4cc0eee96b765aa/docling_parse-4.7.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6cb4fe8c62de06b70e6b38c4bd608f41ea3e9d7154a4e05f9a3c4d8944fe3a25", size = 14616910, upload-time = "2026-01-14T14:17:47.146Z" },
+    { url = "https://files.pythonhosted.org/packages/15/c4/a18d70118ff26b12021effab53d2ffe0c7e6ef378e92c35941b5557529c1/docling_parse-4.7.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9d18a5b1f7eecabed631c497a19f19d281a0d86f24bfe5d239e3df89bdc4df32", size = 14981477, upload-time = "2026-01-14T14:17:49.659Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e6/899f033d80cb2b4e182226c73c6e91660df42e8867b76a04f0c024db7cb6/docling_parse-4.7.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4a93f91f97055e19cade33bb957d83f8615f1d2a0103b89827aca16b31a3e22", size = 15092546, upload-time = "2026-01-14T14:17:51.6Z" },
+    { url = "https://files.pythonhosted.org/packages/95/f3/6dbd2e9c018b44ffe1de3d0a1ea1b017ee25b2a2f21934495710beb6d4d7/docling_parse-4.7.3-cp313-cp313-win_amd64.whl", hash = "sha256:c5a416ae2e1761914ee8d7dbfbe3858e106c876b5a7fccaa3917c038e2f126ec", size = 16147305, upload-time = "2026-01-14T14:17:53.925Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/58/bcf78e156bf261de21c2ab2843f60aefd0b15217af69756a2ff0cd8287f5/docling_parse-4.7.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a6e0f9e18d808c87ce0fe1900c74a3496a42743f4bba7ed4dd83a0e6e168644a", size = 18061956, upload-time = "2026-01-14T14:18:12.96Z" },
 ]
 
 [[package]]
@@ -2247,11 +2246,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/83/1d/d6466de3a5249d35e832a52834115ca9d1d0de6abc22065f049707516d47/google_auth-2.48.0-py3-none-any.whl", hash = "sha256:2e2a537873d449434252a9632c28bfc268b0adb1e53f9fb62afc5333a975903f", size = 236499, upload-time = "2026-01-26T19:22:45.099Z" },
 ]
 
-[package.optional-dependencies]
-requests = [
-    { name = "requests" },
-]
-
 [[package]]
 name = "google-cloud-vision"
 version = "3.12.1"
@@ -2270,23 +2264,21 @@ wheels = [
 
 [[package]]
 name = "google-genai"
-version = "1.65.0"
+version = "1.49.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
-    { name = "distro" },
-    { name = "google-auth", extra = ["requests"] },
+    { name = "google-auth" },
     { name = "httpx" },
     { name = "pydantic" },
     { name = "requests" },
-    { name = "sniffio" },
     { name = "tenacity" },
     { name = "typing-extensions" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/79/f9/cc1191c2540d6a4e24609a586c4ed45d2db57cfef47931c139ee70e5874a/google_genai-1.65.0.tar.gz", hash = "sha256:d470eb600af802d58a79c7f13342d9ea0d05d965007cae8f76c7adff3d7a4750", size = 497206, upload-time = "2026-02-26T00:20:33.824Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/49/1a724ee3c3748fa50721d53a52d9fee88c67d0c43bb16eb2b10ee89ab239/google_genai-1.49.0.tar.gz", hash = "sha256:35eb16023b72e298571ae30e919c810694f258f2ba68fc77a2185c7c8829ad5a", size = 253493, upload-time = "2025-11-05T22:41:03.278Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/68/3c/3fea4e7c91357c71782d7dcaad7a2577d636c90317e003386893c25bc62c/google_genai-1.65.0-py3-none-any.whl", hash = "sha256:68c025205856919bc03edb0155c11b4b833810b7ce17ad4b7a9eeba5158f6c44", size = 724429, upload-time = "2026-02-26T00:20:32.186Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/d3/84a152746dc7bdebb8ba0fd7d6157263044acd1d14b2a53e8df4a307b6b7/google_genai-1.49.0-py3-none-any.whl", hash = "sha256:ad49cd5be5b63397069e7aef9a4fe0a84cbdf25fcd93408e795292308db4ef32", size = 256098, upload-time = "2025-11-05T22:41:01.429Z" },
 ]
 
 [[package]]
@@ -2667,7 +2659,7 @@ dependencies = [
     { name = "jmespath", marker = "platform_python_implementation == 'PyPy'" },
     { name = "python-dateutil", marker = "platform_python_implementation == 'PyPy'" },
     { name = "requests", marker = "platform_python_implementation == 'PyPy'" },
-    { name = "urllib3", marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a5/db/e913f210d66c2ad09521925f29754fb9b7240da11238a29a0186ebad4ffa/ibm_cos_sdk_core-2.14.2.tar.gz", hash = "sha256:d594b2af58f70e892aa3b0f6ae4b0fa5d412422c05beeba083d4561b5fad91b4", size = 1103504, upload-time = "2025-06-18T05:03:42.969Z" }
 
@@ -2685,7 +2677,7 @@ dependencies = [
     { name = "jmespath", marker = "platform_python_implementation != 'PyPy'" },
     { name = "python-dateutil", marker = "platform_python_implementation != 'PyPy'" },
     { name = "requests", marker = "platform_python_implementation != 'PyPy'" },
-    { name = "urllib3", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7e/45/80c23aa1e13175a9deefe43cbf8e853a3d3bfc8dfa8b6d6fe83e5785fe21/ibm_cos_sdk_core-2.14.3.tar.gz", hash = "sha256:85dee7790c92e8db69bf39dae4c02cac211e3c1d81bb86e64fa2d1e929674623", size = 1103637, upload-time = "2025-08-01T06:35:41.645Z" }
 
@@ -2734,7 +2726,8 @@ dependencies = [
     { name = "pandas" },
     { name = "requests" },
     { name = "tabulate" },
-    { name = "urllib3" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/c7/56/2e3df38a1f13062095d7bde23c87a92f3898982993a15186b1bfecbd206f/ibm_watsonx_ai-1.3.42.tar.gz", hash = "sha256:ee5be59009004245d957ce97d1227355516df95a2640189749487614fef674ff", size = 688651, upload-time = "2025-10-01T13:35:41.527Z" }
 wheels = [
@@ -3221,7 +3214,8 @@ dependencies = [
     { name = "requests" },
     { name = "requests-oauthlib" },
     { name = "six" },
-    { name = "urllib3" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
     { name = "websocket-client" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/2c/8f/85bf51ad4150f64e8c665daf0d9dfe9787ae92005efb9a4d1cba592bd79d/kubernetes-35.0.0.tar.gz", hash = "sha256:3d00d344944239821458b9efd484d6df9f011da367ecb155dadf9513f05f09ee", size = 1094642, upload-time = "2026-01-16T01:05:27.76Z" }
@@ -3249,7 +3243,8 @@ dependencies = [
     { name = "pydantic" },
     { name = "python-dateutil" },
     { name = "typing-extensions" },
-    { name = "urllib3" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/e9/64/51622c93ec8c164483c83b68764e5e76e52286c0137a8247bc6a7fac25f4/lance_namespace_urllib3_client-0.5.2.tar.gz", hash = "sha256:8a3a238006e6eabc01fc9d385ac3de22ba933aef0ae8987558f3c3199c9b3799", size = 172578, upload-time = "2026-02-20T03:14:33.031Z" }
 wheels = [
@@ -3295,7 +3290,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "0.3.83"
+version = "0.3.76"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
@@ -3305,11 +3300,10 @@ dependencies = [
     { name = "pyyaml" },
     { name = "tenacity" },
     { name = "typing-extensions" },
-    { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/21/a4/24f2d787bfcf56e5990924cacefe6f6e7971a3629f97c8162fc7a2a3d851/langchain_core-0.3.83.tar.gz", hash = "sha256:a0a4c7b6ea1c446d3b432116f405dc2afa1fe7891c44140d3d5acca221909415", size = 597965, upload-time = "2026-01-13T01:19:23.854Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4f/4d/5e2ea7754ee0a1f524c412801c6ba9ad49318ecb58b0d524903c3d9efe0a/langchain_core-0.3.76.tar.gz", hash = "sha256:71136a122dd1abae2c289c5809d035cf12b5f2bb682d8a4c1078cd94feae7419", size = 573568, upload-time = "2025-09-10T14:49:39.863Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/db/d71b80d3bd6193812485acea4001cdf86cf95a44bbf942f7a240120ff762/langchain_core-0.3.83-py3-none-any.whl", hash = "sha256:8c92506f8b53fc1958b1c07447f58c5783eb8833dd3cb6dc75607c80891ab1ae", size = 458890, upload-time = "2026-01-13T01:19:21.748Z" },
+    { url = "https://files.pythonhosted.org/packages/77/b5/501c0ffcb09c734457ceaa86bc7b1dd37b6a261147bd653add03b838aacb/langchain_core-0.3.76-py3-none-any.whl", hash = "sha256:46e0eb48c7ac532432d51f8ca1ece1804c82afe9ae3dcf027b867edadf82b3ec", size = 447508, upload-time = "2025-09-10T14:49:38.179Z" },
 ]
 
 [[package]]
@@ -4147,54 +4141,54 @@ wheels = [
 
 [[package]]
 name = "mypy"
-version = "1.19.1"
+version = "1.19.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "librt", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "librt" },
     { name = "mypy-extensions" },
     { name = "pathspec" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404, upload-time = "2025-12-15T05:03:48.42Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/b5/b58cdc25fadd424552804bf410855d52324183112aa004f0732c5f6324cf/mypy-1.19.0.tar.gz", hash = "sha256:f6b874ca77f733222641e5c46e4711648c4037ea13646fd0cdc814c2eaec2528", size = 3579025, upload-time = "2025-11-28T15:49:01.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2f/63/e499890d8e39b1ff2df4c0c6ce5d371b6844ee22b8250687a99fd2f657a8/mypy-1.19.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5f05aa3d375b385734388e844bc01733bd33c644ab48e9684faa54e5389775ec", size = 13101333, upload-time = "2025-12-15T05:03:03.28Z" },
-    { url = "https://files.pythonhosted.org/packages/72/4b/095626fc136fba96effc4fd4a82b41d688ab92124f8c4f7564bffe5cf1b0/mypy-1.19.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:022ea7279374af1a5d78dfcab853fe6a536eebfda4b59deab53cd21f6cd9f00b", size = 12164102, upload-time = "2025-12-15T05:02:33.611Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/5b/952928dd081bf88a83a5ccd49aaecfcd18fd0d2710c7ff07b8fb6f7032b9/mypy-1.19.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee4c11e460685c3e0c64a4c5de82ae143622410950d6be863303a1c4ba0e36d6", size = 12765799, upload-time = "2025-12-15T05:03:28.44Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/0d/93c2e4a287f74ef11a66fb6d49c7a9f05e47b0a4399040e6719b57f500d2/mypy-1.19.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de759aafbae8763283b2ee5869c7255391fbc4de3ff171f8f030b5ec48381b74", size = 13522149, upload-time = "2025-12-15T05:02:36.011Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/0e/33a294b56aaad2b338d203e3a1d8b453637ac36cb278b45005e0901cf148/mypy-1.19.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ab43590f9cd5108f41aacf9fca31841142c786827a74ab7cc8a2eacb634e09a1", size = 13810105, upload-time = "2025-12-15T05:02:40.327Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/fd/3e82603a0cb66b67c5e7abababce6bf1a929ddf67bf445e652684af5c5a0/mypy-1.19.1-cp310-cp310-win_amd64.whl", hash = "sha256:2899753e2f61e571b3971747e302d5f420c3fd09650e1951e99f823bc3089dac", size = 10057200, upload-time = "2025-12-15T05:02:51.012Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/47/6b3ebabd5474d9cdc170d1342fbf9dddc1b0ec13ec90bf9004ee6f391c31/mypy-1.19.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d8dfc6ab58ca7dda47d9237349157500468e404b17213d44fc1cb77bce532288", size = 13028539, upload-time = "2025-12-15T05:03:44.129Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/a6/ac7c7a88a3c9c54334f53a941b765e6ec6c4ebd65d3fe8cdcfbe0d0fd7db/mypy-1.19.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e3f276d8493c3c97930e354b2595a44a21348b320d859fb4a2b9f66da9ed27ab", size = 12083163, upload-time = "2025-12-15T05:03:37.679Z" },
-    { url = "https://files.pythonhosted.org/packages/67/af/3afa9cf880aa4a2c803798ac24f1d11ef72a0c8079689fac5cfd815e2830/mypy-1.19.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2abb24cf3f17864770d18d673c85235ba52456b36a06b6afc1e07c1fdcd3d0e6", size = 12687629, upload-time = "2025-12-15T05:02:31.526Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/46/20f8a7114a56484ab268b0ab372461cb3a8f7deed31ea96b83a4e4cfcfca/mypy-1.19.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a009ffa5a621762d0c926a078c2d639104becab69e79538a494bcccb62cc0331", size = 13436933, upload-time = "2025-12-15T05:03:15.606Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/f8/33b291ea85050a21f15da910002460f1f445f8007adb29230f0adea279cb/mypy-1.19.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f7cee03c9a2e2ee26ec07479f38ea9c884e301d42c6d43a19d20fb014e3ba925", size = 13661754, upload-time = "2025-12-15T05:02:26.731Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/a3/47cbd4e85bec4335a9cd80cf67dbc02be21b5d4c9c23ad6b95d6c5196bac/mypy-1.19.1-cp311-cp311-win_amd64.whl", hash = "sha256:4b84a7a18f41e167f7995200a1d07a4a6810e89d29859df936f1c3923d263042", size = 10055772, upload-time = "2025-12-15T05:03:26.179Z" },
-    { url = "https://files.pythonhosted.org/packages/06/8a/19bfae96f6615aa8a0604915512e0289b1fad33d5909bf7244f02935d33a/mypy-1.19.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8174a03289288c1f6c46d55cef02379b478bfbc8e358e02047487cad44c6ca1", size = 13206053, upload-time = "2025-12-15T05:03:46.622Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/34/3e63879ab041602154ba2a9f99817bb0c85c4df19a23a1443c8986e4d565/mypy-1.19.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffcebe56eb09ff0c0885e750036a095e23793ba6c2e894e7e63f6d89ad51f22e", size = 12219134, upload-time = "2025-12-15T05:03:24.367Z" },
-    { url = "https://files.pythonhosted.org/packages/89/cc/2db6f0e95366b630364e09845672dbee0cbf0bbe753a204b29a944967cd9/mypy-1.19.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b64d987153888790bcdb03a6473d321820597ab8dd9243b27a92153c4fa50fd2", size = 12731616, upload-time = "2025-12-15T05:02:44.725Z" },
-    { url = "https://files.pythonhosted.org/packages/00/be/dd56c1fd4807bc1eba1cf18b2a850d0de7bacb55e158755eb79f77c41f8e/mypy-1.19.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c35d298c2c4bba75feb2195655dfea8124d855dfd7343bf8b8c055421eaf0cf8", size = 13620847, upload-time = "2025-12-15T05:03:39.633Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/42/332951aae42b79329f743bf1da088cd75d8d4d9acc18fbcbd84f26c1af4e/mypy-1.19.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:34c81968774648ab5ac09c29a375fdede03ba253f8f8287847bd480782f73a6a", size = 13834976, upload-time = "2025-12-15T05:03:08.786Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/63/e7493e5f90e1e085c562bb06e2eb32cae27c5057b9653348d38b47daaecc/mypy-1.19.1-cp312-cp312-win_amd64.whl", hash = "sha256:b10e7c2cd7870ba4ad9b2d8a6102eb5ffc1f16ca35e3de6bfa390c1113029d13", size = 10118104, upload-time = "2025-12-15T05:03:10.834Z" },
-    { url = "https://files.pythonhosted.org/packages/de/9f/a6abae693f7a0c697dbb435aac52e958dc8da44e92e08ba88d2e42326176/mypy-1.19.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e3157c7594ff2ef1634ee058aafc56a82db665c9438fd41b390f3bde1ab12250", size = 13201927, upload-time = "2025-12-15T05:02:29.138Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/a4/45c35ccf6e1c65afc23a069f50e2c66f46bd3798cbe0d680c12d12935caa/mypy-1.19.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdb12f69bcc02700c2b47e070238f42cb87f18c0bc1fc4cdb4fb2bc5fd7a3b8b", size = 12206730, upload-time = "2025-12-15T05:03:01.325Z" },
-    { url = "https://files.pythonhosted.org/packages/05/bb/cdcf89678e26b187650512620eec8368fded4cfd99cfcb431e4cdfd19dec/mypy-1.19.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f859fb09d9583a985be9a493d5cfc5515b56b08f7447759a0c5deaf68d80506e", size = 12724581, upload-time = "2025-12-15T05:03:20.087Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/32/dd260d52babf67bad8e6770f8e1102021877ce0edea106e72df5626bb0ec/mypy-1.19.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9a6538e0415310aad77cb94004ca6482330fece18036b5f360b62c45814c4ef", size = 13616252, upload-time = "2025-12-15T05:02:49.036Z" },
-    { url = "https://files.pythonhosted.org/packages/71/d0/5e60a9d2e3bd48432ae2b454b7ef2b62a960ab51292b1eda2a95edd78198/mypy-1.19.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:da4869fc5e7f62a88f3fe0b5c919d1d9f7ea3cef92d3689de2823fd27e40aa75", size = 13840848, upload-time = "2025-12-15T05:02:55.95Z" },
-    { url = "https://files.pythonhosted.org/packages/98/76/d32051fa65ecf6cc8c6610956473abdc9b4c43301107476ac03559507843/mypy-1.19.1-cp313-cp313-win_amd64.whl", hash = "sha256:016f2246209095e8eda7538944daa1d60e1e8134d98983b9fc1e92c1fc0cb8dd", size = 10135510, upload-time = "2025-12-15T05:02:58.438Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239, upload-time = "2025-12-15T05:03:07.248Z" },
+    { url = "https://files.pythonhosted.org/packages/98/8f/55fb488c2b7dabd76e3f30c10f7ab0f6190c1fcbc3e97b1e588ec625bbe2/mypy-1.19.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6148ede033982a8c5ca1143de34c71836a09f105068aaa8b7d5edab2b053e6c8", size = 13093239, upload-time = "2025-11-28T15:45:11.342Z" },
+    { url = "https://files.pythonhosted.org/packages/72/1b/278beea978456c56b3262266274f335c3ba5ff2c8108b3b31bec1ffa4c1d/mypy-1.19.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a9ac09e52bb0f7fb912f5d2a783345c72441a08ef56ce3e17c1752af36340a39", size = 12156128, upload-time = "2025-11-28T15:46:02.566Z" },
+    { url = "https://files.pythonhosted.org/packages/21/f8/e06f951902e136ff74fd7a4dc4ef9d884faeb2f8eb9c49461235714f079f/mypy-1.19.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11f7254c15ab3f8ed68f8e8f5cbe88757848df793e31c36aaa4d4f9783fd08ab", size = 12753508, upload-time = "2025-11-28T15:44:47.538Z" },
+    { url = "https://files.pythonhosted.org/packages/67/5a/d035c534ad86e09cee274d53cf0fd769c0b29ca6ed5b32e205be3c06878c/mypy-1.19.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318ba74f75899b0e78b847d8c50821e4c9637c79d9a59680fc1259f29338cb3e", size = 13507553, upload-time = "2025-11-28T15:44:39.26Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/17/c4a5498e00071ef29e483a01558b285d086825b61cf1fb2629fbdd019d94/mypy-1.19.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cf7d84f497f78b682edd407f14a7b6e1a2212b433eedb054e2081380b7395aa3", size = 13792898, upload-time = "2025-11-28T15:44:31.102Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f6/bb542422b3ee4399ae1cdc463300d2d91515ab834c6233f2fd1d52fa21e0/mypy-1.19.0-cp310-cp310-win_amd64.whl", hash = "sha256:c3385246593ac2b97f155a0e9639be906e73534630f663747c71908dfbf26134", size = 10048835, upload-time = "2025-11-28T15:48:15.744Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/d2/010fb171ae5ac4a01cc34fbacd7544531e5ace95c35ca166dd8fd1b901d0/mypy-1.19.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a31e4c28e8ddb042c84c5e977e28a21195d086aaffaf08b016b78e19c9ef8106", size = 13010563, upload-time = "2025-11-28T15:48:23.975Z" },
+    { url = "https://files.pythonhosted.org/packages/41/6b/63f095c9f1ce584fdeb595d663d49e0980c735a1d2004720ccec252c5d47/mypy-1.19.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:34ec1ac66d31644f194b7c163d7f8b8434f1b49719d403a5d26c87fff7e913f7", size = 12077037, upload-time = "2025-11-28T15:47:51.582Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/83/6cb93d289038d809023ec20eb0b48bbb1d80af40511fa077da78af6ff7c7/mypy-1.19.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cb64b0ba5980466a0f3f9990d1c582bcab8db12e29815ecb57f1408d99b4bff7", size = 12680255, upload-time = "2025-11-28T15:46:57.628Z" },
+    { url = "https://files.pythonhosted.org/packages/99/db/d217815705987d2cbace2edd9100926196d6f85bcb9b5af05058d6e3c8ad/mypy-1.19.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:120cffe120cca5c23c03c77f84abc0c14c5d2e03736f6c312480020082f1994b", size = 13421472, upload-time = "2025-11-28T15:47:59.655Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/51/d2beaca7c497944b07594f3f8aad8d2f0e8fc53677059848ae5d6f4d193e/mypy-1.19.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7a500ab5c444268a70565e374fc803972bfd1f09545b13418a5174e29883dab7", size = 13651823, upload-time = "2025-11-28T15:45:29.318Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/d1/7883dcf7644db3b69490f37b51029e0870aac4a7ad34d09ceae709a3df44/mypy-1.19.0-cp311-cp311-win_amd64.whl", hash = "sha256:c14a98bc63fd867530e8ec82f217dae29d0550c86e70debc9667fff1ec83284e", size = 10049077, upload-time = "2025-11-28T15:45:39.818Z" },
+    { url = "https://files.pythonhosted.org/packages/11/7e/1afa8fb188b876abeaa14460dc4983f909aaacaa4bf5718c00b2c7e0b3d5/mypy-1.19.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0fb3115cb8fa7c5f887c8a8d81ccdcb94cff334684980d847e5a62e926910e1d", size = 13207728, upload-time = "2025-11-28T15:46:26.463Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/13/f103d04962bcbefb1644f5ccb235998b32c337d6c13145ea390b9da47f3e/mypy-1.19.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3e19e3b897562276bb331074d64c076dbdd3e79213f36eed4e592272dabd760", size = 12202945, upload-time = "2025-11-28T15:48:49.143Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/93/a86a5608f74a22284a8ccea8592f6e270b61f95b8588951110ad797c2ddd/mypy-1.19.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b9d491295825182fba01b6ffe2c6fe4e5a49dbf4e2bb4d1217b6ced3b4797bc6", size = 12718673, upload-time = "2025-11-28T15:47:37.193Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/58/cf08fff9ced0423b858f2a7495001fda28dc058136818ee9dffc31534ea9/mypy-1.19.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6016c52ab209919b46169651b362068f632efcd5eb8ef9d1735f6f86da7853b2", size = 13608336, upload-time = "2025-11-28T15:48:32.625Z" },
+    { url = "https://files.pythonhosted.org/packages/64/ed/9c509105c5a6d4b73bb08733102a3ea62c25bc02c51bca85e3134bf912d3/mypy-1.19.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f188dcf16483b3e59f9278c4ed939ec0254aa8a60e8fc100648d9ab5ee95a431", size = 13833174, upload-time = "2025-11-28T15:45:48.091Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/71/01939b66e35c6f8cb3e6fdf0b657f0fd24de2f8ba5e523625c8e72328208/mypy-1.19.0-cp312-cp312-win_amd64.whl", hash = "sha256:0e3c3d1e1d62e678c339e7ade72746a9e0325de42cd2cccc51616c7b2ed1a018", size = 10112208, upload-time = "2025-11-28T15:46:41.702Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0d/a1357e6bb49e37ce26fcf7e3cc55679ce9f4ebee0cd8b6ee3a0e301a9210/mypy-1.19.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7686ed65dbabd24d20066f3115018d2dce030d8fa9db01aa9f0a59b6813e9f9e", size = 13191993, upload-time = "2025-11-28T15:47:22.336Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/75/8e5d492a879ec4490e6ba664b5154e48c46c85b5ac9785792a5ec6a4d58f/mypy-1.19.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fd4a985b2e32f23bead72e2fb4bbe5d6aceee176be471243bd831d5b2644672d", size = 12174411, upload-time = "2025-11-28T15:44:55.492Z" },
+    { url = "https://files.pythonhosted.org/packages/71/31/ad5dcee9bfe226e8eaba777e9d9d251c292650130f0450a280aec3485370/mypy-1.19.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fc51a5b864f73a3a182584b1ac75c404396a17eced54341629d8bdcb644a5bba", size = 12727751, upload-time = "2025-11-28T15:44:14.169Z" },
+    { url = "https://files.pythonhosted.org/packages/77/06/b6b8994ce07405f6039701f4b66e9d23f499d0b41c6dd46ec28f96d57ec3/mypy-1.19.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:37af5166f9475872034b56c5efdcf65ee25394e9e1d172907b84577120714364", size = 13593323, upload-time = "2025-11-28T15:46:34.699Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b1/126e274484cccdf099a8e328d4fda1c7bdb98a5e888fa6010b00e1bbf330/mypy-1.19.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:510c014b722308c9bd377993bcbf9a07d7e0692e5fa8fc70e639c1eb19fc6bee", size = 13818032, upload-time = "2025-11-28T15:46:18.286Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/56/53a8f70f562dfc466c766469133a8a4909f6c0012d83993143f2a9d48d2d/mypy-1.19.0-cp313-cp313-win_amd64.whl", hash = "sha256:cabbee74f29aa9cd3b444ec2f1e4fa5a9d0d746ce7567a6a609e224429781f53", size = 10120644, upload-time = "2025-11-28T15:47:43.99Z" },
+    { url = "https://files.pythonhosted.org/packages/09/0e/fe228ed5aeab470c6f4eb82481837fadb642a5aa95cc8215fd2214822c10/mypy-1.19.0-py3-none-any.whl", hash = "sha256:0c01c99d626380752e527d5ce8e69ffbba2046eb8a060db0329690849cf9b6f9", size = 2469714, upload-time = "2025-11-28T15:45:33.22Z" },
 ]
 
 [[package]]
 name = "mypy-boto3-bedrock-runtime"
-version = "1.42.42"
+version = "1.40.76"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.12'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/46/bb/65dc1b2c5796a6ab5f60bdb57343bd6c3ecb82251c580eca415c8548333e/mypy_boto3_bedrock_runtime-1.42.42.tar.gz", hash = "sha256:3a4088218478b6fbbc26055c03c95bee4fc04624a801090b3cce3037e8275c8d", size = 29840, upload-time = "2026-02-04T20:53:05.999Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/db/cc668a48a27973df31c7044a6785bd0e8691b1a0419dae001c4c29f1c98f/mypy_boto3_bedrock_runtime-1.40.76.tar.gz", hash = "sha256:52f2a2b3955eb9f4f0d075398f2d430abcc6bf56ff00815b94e3371e66030059", size = 28428, upload-time = "2025-11-18T21:42:43.41Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/43/7ea062f2228f47b5779dcfa14dab48d6e29f979b35d1a5102b0ba80b9c1b/mypy_boto3_bedrock_runtime-1.42.42-py3-none-any.whl", hash = "sha256:b2d16eae22607d0685f90796b3a0afc78c0b09d45872e00eafd634a31dd9358f", size = 36077, upload-time = "2026-02-04T20:53:01.768Z" },
+    { url = "https://files.pythonhosted.org/packages/05/6f/8b04729224a76952e08406eccbbbebfa75ee7df91313279d76428f13fdc2/mypy_boto3_bedrock_runtime-1.40.76-py3-none-any.whl", hash = "sha256:0347f6d78e342d640da74bbd6158b276c5cb39ef73405084a65fe490766b6dab", size = 34454, upload-time = "2025-11-18T21:42:42.156Z" },
 ]
 
 [[package]]
@@ -4854,11 +4848,11 @@ wheels = [
 
 [[package]]
 name = "packaging"
-version = "25.0"
+version = "26.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
 ]
 
 [[package]]
@@ -5110,75 +5104,61 @@ wheels = [
 
 [[package]]
 name = "pillow"
-version = "12.1.1"
+version = "10.4.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1f/42/5c74462b4fd957fcd7b13b04fb3205ff8349236ea74c7c375766d6c82288/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4", size = 46980264, upload-time = "2026-02-11T04:23:07.146Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/74/ad3d526f3bf7b6d3f408b73fde271ec69dfac8b81341a318ce825f2b3812/pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06", size = 46555059, upload-time = "2024-07-01T09:48:43.583Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/30/5bd3d794762481f8c8ae9c80e7b76ecea73b916959eb587521358ef0b2f9/pillow-12.1.1-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1f1625b72740fdda5d77b4def688eb8fd6490975d06b909fd19f13f391e077e0", size = 5304099, upload-time = "2026-02-11T04:20:06.13Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/c1/aab9e8f3eeb4490180e357955e15c2ef74b31f64790ff356c06fb6cf6d84/pillow-12.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:178aa072084bd88ec759052feca8e56cbb14a60b39322b99a049e58090479713", size = 4657880, upload-time = "2026-02-11T04:20:09.291Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/0a/9879e30d56815ad529d3985aeff5af4964202425c27261a6ada10f7cbf53/pillow-12.1.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b66e95d05ba806247aaa1561f080abc7975daf715c30780ff92a20e4ec546e1b", size = 6222587, upload-time = "2026-02-11T04:20:10.82Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/5f/a1b72ff7139e4f89014e8d451442c74a774d5c43cd938fb0a9f878576b37/pillow-12.1.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:89c7e895002bbe49cdc5426150377cbbc04767d7547ed145473f496dfa40408b", size = 8027678, upload-time = "2026-02-11T04:20:12.455Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/c2/c7cb187dac79a3d22c3ebeae727abee01e077c8c7d930791dc592f335153/pillow-12.1.1-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a5cbdcddad0af3da87cb16b60d23648bc3b51967eb07223e9fed77a82b457c4", size = 6335777, upload-time = "2026-02-11T04:20:14.441Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/7b/f9b09a7804ec7336effb96c26d37c29d27225783dc1501b7d62dcef6ae25/pillow-12.1.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9f51079765661884a486727f0729d29054242f74b46186026582b4e4769918e4", size = 7027140, upload-time = "2026-02-11T04:20:16.387Z" },
-    { url = "https://files.pythonhosted.org/packages/98/b2/2fa3c391550bd421b10849d1a2144c44abcd966daadd2f7c12e19ea988c4/pillow-12.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:99c1506ea77c11531d75e3a412832a13a71c7ebc8192ab9e4b2e355555920e3e", size = 6449855, upload-time = "2026-02-11T04:20:18.554Z" },
-    { url = "https://files.pythonhosted.org/packages/96/ff/9caf4b5b950c669263c39e96c78c0d74a342c71c4f43fd031bb5cb7ceac9/pillow-12.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:36341d06738a9f66c8287cf8b876d24b18db9bd8740fa0672c74e259ad408cff", size = 7151329, upload-time = "2026-02-11T04:20:20.646Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/f8/4b24841f582704da675ca535935bccb32b00a6da1226820845fac4a71136/pillow-12.1.1-cp310-cp310-win32.whl", hash = "sha256:6c52f062424c523d6c4db85518774cc3d50f5539dd6eed32b8f6229b26f24d40", size = 6325574, upload-time = "2026-02-11T04:20:22.43Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/f9/9f6b01c0881d7036063aa6612ef04c0e2cad96be21325a1e92d0203f8e91/pillow-12.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:c6008de247150668a705a6338156efb92334113421ceecf7438a12c9a12dab23", size = 7032347, upload-time = "2026-02-11T04:20:23.932Z" },
-    { url = "https://files.pythonhosted.org/packages/79/13/c7922edded3dcdaf10c59297540b72785620abc0538872c819915746757d/pillow-12.1.1-cp310-cp310-win_arm64.whl", hash = "sha256:1a9b0ee305220b392e1124a764ee4265bd063e54a751a6b62eff69992f457fa9", size = 2453457, upload-time = "2026-02-11T04:20:25.392Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/46/5da1ec4a5171ee7bf1a0efa064aba70ba3d6e0788ce3f5acd1375d23c8c0/pillow-12.1.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e879bb6cd5c73848ef3b2b48b8af9ff08c5b71ecda8048b7dd22d8a33f60be32", size = 5304084, upload-time = "2026-02-11T04:20:27.501Z" },
-    { url = "https://files.pythonhosted.org/packages/78/93/a29e9bc02d1cf557a834da780ceccd54e02421627200696fcf805ebdc3fb/pillow-12.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:365b10bb9417dd4498c0e3b128018c4a624dc11c7b97d8cc54effe3b096f4c38", size = 4657866, upload-time = "2026-02-11T04:20:29.827Z" },
-    { url = "https://files.pythonhosted.org/packages/13/84/583a4558d492a179d31e4aae32eadce94b9acf49c0337c4ce0b70e0a01f2/pillow-12.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d4ce8e329c93845720cd2014659ca67eac35f6433fd3050393d85f3ecef0dad5", size = 6232148, upload-time = "2026-02-11T04:20:31.329Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/e2/53c43334bbbb2d3b938978532fbda8e62bb6e0b23a26ce8592f36bcc4987/pillow-12.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc354a04072b765eccf2204f588a7a532c9511e8b9c7f900e1b64e3e33487090", size = 8038007, upload-time = "2026-02-11T04:20:34.225Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/a6/3d0e79c8a9d58150dd98e199d7c1c56861027f3829a3a60b3c2784190180/pillow-12.1.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e7976bf1910a8116b523b9f9f58bf410f3e8aa330cd9a2bb2953f9266ab49af", size = 6345418, upload-time = "2026-02-11T04:20:35.858Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/c8/46dfeac5825e600579157eea177be43e2f7ff4a99da9d0d0a49533509ac5/pillow-12.1.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:597bd9c8419bc7c6af5604e55847789b69123bbe25d65cc6ad3012b4f3c98d8b", size = 7034590, upload-time = "2026-02-11T04:20:37.91Z" },
-    { url = "https://files.pythonhosted.org/packages/af/bf/e6f65d3db8a8bbfeaf9e13cc0417813f6319863a73de934f14b2229ada18/pillow-12.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2c1fc0f2ca5f96a3c8407e41cca26a16e46b21060fe6d5b099d2cb01412222f5", size = 6458655, upload-time = "2026-02-11T04:20:39.496Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/c2/66091f3f34a25894ca129362e510b956ef26f8fb67a0e6417bc5744e56f1/pillow-12.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:578510d88c6229d735855e1f278aa305270438d36a05031dfaae5067cc8eb04d", size = 7159286, upload-time = "2026-02-11T04:20:41.139Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/5a/24bc8eb526a22f957d0cec6243146744966d40857e3d8deb68f7902ca6c1/pillow-12.1.1-cp311-cp311-win32.whl", hash = "sha256:7311c0a0dcadb89b36b7025dfd8326ecfa36964e29913074d47382706e516a7c", size = 6328663, upload-time = "2026-02-11T04:20:43.184Z" },
-    { url = "https://files.pythonhosted.org/packages/31/03/bef822e4f2d8f9d7448c133d0a18185d3cce3e70472774fffefe8b0ed562/pillow-12.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:fbfa2a7c10cc2623f412753cddf391c7f971c52ca40a3f65dc5039b2939e8563", size = 7031448, upload-time = "2026-02-11T04:20:44.696Z" },
-    { url = "https://files.pythonhosted.org/packages/49/70/f76296f53610bd17b2e7d31728b8b7825e3ac3b5b3688b51f52eab7c0818/pillow-12.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:b81b5e3511211631b3f672a595e3221252c90af017e399056d0faabb9538aa80", size = 2453651, upload-time = "2026-02-11T04:20:46.243Z" },
-    { url = "https://files.pythonhosted.org/packages/07/d3/8df65da0d4df36b094351dce696f2989bec731d4f10e743b1c5f4da4d3bf/pillow-12.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052", size = 5262803, upload-time = "2026-02-11T04:20:47.653Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/71/5026395b290ff404b836e636f51d7297e6c83beceaa87c592718747e670f/pillow-12.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984", size = 4657601, upload-time = "2026-02-11T04:20:49.328Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/2e/1001613d941c67442f745aff0f7cc66dd8df9a9c084eb497e6a543ee6f7e/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79", size = 6234995, upload-time = "2026-02-11T04:20:51.032Z" },
-    { url = "https://files.pythonhosted.org/packages/07/26/246ab11455b2549b9233dbd44d358d033a2f780fa9007b61a913c5b2d24e/pillow-12.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293", size = 8045012, upload-time = "2026-02-11T04:20:52.882Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/8b/07587069c27be7535ac1fe33874e32de118fbd34e2a73b7f83436a88368c/pillow-12.1.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397", size = 6349638, upload-time = "2026-02-11T04:20:54.444Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/79/6df7b2ee763d619cda2fb4fea498e5f79d984dae304d45a8999b80d6cf5c/pillow-12.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0", size = 7041540, upload-time = "2026-02-11T04:20:55.97Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/5e/2ba19e7e7236d7529f4d873bdaf317a318896bac289abebd4bb00ef247f0/pillow-12.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3", size = 6462613, upload-time = "2026-02-11T04:20:57.542Z" },
-    { url = "https://files.pythonhosted.org/packages/03/03/31216ec124bb5c3dacd74ce8efff4cc7f52643653bad4825f8f08c697743/pillow-12.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35", size = 7166745, upload-time = "2026-02-11T04:20:59.196Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/e7/7c4552d80052337eb28653b617eafdef39adfb137c49dd7e831b8dc13bc5/pillow-12.1.1-cp312-cp312-win32.whl", hash = "sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a", size = 6328823, upload-time = "2026-02-11T04:21:01.385Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/17/688626d192d7261bbbf98846fc98995726bddc2c945344b65bec3a29d731/pillow-12.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6", size = 7033367, upload-time = "2026-02-11T04:21:03.536Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/fe/a0ef1f73f939b0eca03ee2c108d0043a87468664770612602c63266a43c4/pillow-12.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523", size = 2453811, upload-time = "2026-02-11T04:21:05.116Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/11/6db24d4bd7685583caeae54b7009584e38da3c3d4488ed4cd25b439de486/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e", size = 4062689, upload-time = "2026-02-11T04:21:06.804Z" },
-    { url = "https://files.pythonhosted.org/packages/33/c0/ce6d3b1fe190f0021203e0d9b5b99e57843e345f15f9ef22fcd43842fd21/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9", size = 4138535, upload-time = "2026-02-11T04:21:08.452Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/c6/d5eb6a4fb32a3f9c21a8c7613ec706534ea1cf9f4b3663e99f0d83f6fca8/pillow-12.1.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6", size = 3601364, upload-time = "2026-02-11T04:21:10.194Z" },
-    { url = "https://files.pythonhosted.org/packages/14/a1/16c4b823838ba4c9c52c0e6bbda903a3fe5a1bdbf1b8eb4fff7156f3e318/pillow-12.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60", size = 5262561, upload-time = "2026-02-11T04:21:11.742Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/ad/ad9dc98ff24f485008aa5cdedaf1a219876f6f6c42a4626c08bc4e80b120/pillow-12.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2", size = 4657460, upload-time = "2026-02-11T04:21:13.786Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/1b/f1a4ea9a895b5732152789326202a82464d5254759fbacae4deea3069334/pillow-12.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850", size = 6232698, upload-time = "2026-02-11T04:21:15.949Z" },
-    { url = "https://files.pythonhosted.org/packages/95/f4/86f51b8745070daf21fd2e5b1fe0eb35d4db9ca26e6d58366562fb56a743/pillow-12.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289", size = 8041706, upload-time = "2026-02-11T04:21:17.723Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9b/d6ecd956bb1266dd1045e995cce9b8d77759e740953a1c9aad9502a0461e/pillow-12.1.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e", size = 6346621, upload-time = "2026-02-11T04:21:19.547Z" },
-    { url = "https://files.pythonhosted.org/packages/71/24/538bff45bde96535d7d998c6fed1a751c75ac7c53c37c90dc2601b243893/pillow-12.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717", size = 7038069, upload-time = "2026-02-11T04:21:21.378Z" },
-    { url = "https://files.pythonhosted.org/packages/94/0e/58cb1a6bc48f746bc4cb3adb8cabff73e2742c92b3bf7a220b7cf69b9177/pillow-12.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a", size = 6460040, upload-time = "2026-02-11T04:21:23.148Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/57/9045cb3ff11eeb6c1adce3b2d60d7d299d7b273a2e6c8381a524abfdc474/pillow-12.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029", size = 7164523, upload-time = "2026-02-11T04:21:25.01Z" },
-    { url = "https://files.pythonhosted.org/packages/73/f2/9be9cb99f2175f0d4dbadd6616ce1bf068ee54a28277ea1bf1fbf729c250/pillow-12.1.1-cp313-cp313-win32.whl", hash = "sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b", size = 6332552, upload-time = "2026-02-11T04:21:27.238Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/eb/b0834ad8b583d7d9d42b80becff092082a1c3c156bb582590fcc973f1c7c/pillow-12.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1", size = 7040108, upload-time = "2026-02-11T04:21:29.462Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/7d/fc09634e2aabdd0feabaff4a32f4a7d97789223e7c2042fd805ea4b4d2c2/pillow-12.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a", size = 2453712, upload-time = "2026-02-11T04:21:31.072Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2a/b9d62794fc8a0dd14c1943df68347badbd5511103e0d04c035ffe5cf2255/pillow-12.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da", size = 5264880, upload-time = "2026-02-11T04:21:32.865Z" },
-    { url = "https://files.pythonhosted.org/packages/26/9d/e03d857d1347fa5ed9247e123fcd2a97b6220e15e9cb73ca0a8d91702c6e/pillow-12.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc", size = 4660616, upload-time = "2026-02-11T04:21:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/ec/8a6d22afd02570d30954e043f09c32772bfe143ba9285e2fdb11284952cd/pillow-12.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c", size = 6269008, upload-time = "2026-02-11T04:21:36.623Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/1d/6d875422c9f28a4a361f495a5f68d9de4a66941dc2c619103ca335fa6446/pillow-12.1.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8", size = 8073226, upload-time = "2026-02-11T04:21:38.585Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/cd/134b0b6ee5eda6dc09e25e24b40fdafe11a520bc725c1d0bbaa5e00bf95b/pillow-12.1.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20", size = 6380136, upload-time = "2026-02-11T04:21:40.562Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/a9/7628f013f18f001c1b98d8fffe3452f306a70dc6aba7d931019e0492f45e/pillow-12.1.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13", size = 7067129, upload-time = "2026-02-11T04:21:42.521Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/f8/66ab30a2193b277785601e82ee2d49f68ea575d9637e5e234faaa98efa4c/pillow-12.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf", size = 6491807, upload-time = "2026-02-11T04:21:44.22Z" },
-    { url = "https://files.pythonhosted.org/packages/da/0b/a877a6627dc8318fdb84e357c5e1a758c0941ab1ddffdafd231983788579/pillow-12.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524", size = 7190954, upload-time = "2026-02-11T04:21:46.114Z" },
-    { url = "https://files.pythonhosted.org/packages/83/43/6f732ff85743cf746b1361b91665d9f5155e1483817f693f8d57ea93147f/pillow-12.1.1-cp313-cp313t-win32.whl", hash = "sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986", size = 6336441, upload-time = "2026-02-11T04:21:48.22Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/44/e865ef3986611bb75bfabdf94a590016ea327833f434558801122979cd0e/pillow-12.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c", size = 7045383, upload-time = "2026-02-11T04:21:50.015Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/c6/f4fb24268d0c6908b9f04143697ea18b0379490cb74ba9e8d41b898bd005/pillow-12.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3", size = 2456104, upload-time = "2026-02-11T04:21:51.633Z" },
-    { url = "https://files.pythonhosted.org/packages/56/11/5d43209aa4cb58e0cc80127956ff1796a68b928e6324bbf06ef4db34367b/pillow-12.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:600fd103672b925fe62ed08e0d874ea34d692474df6f4bf7ebe148b30f89f39f", size = 5228606, upload-time = "2026-02-11T04:22:52.106Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/d5/3b005b4e4fda6698b371fa6c21b097d4707585d7db99e98d9b0b87ac612a/pillow-12.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:665e1b916b043cef294bc54d47bf02d87e13f769bc4bc5fa225a24b3a6c5aca9", size = 4622321, upload-time = "2026-02-11T04:22:53.827Z" },
-    { url = "https://files.pythonhosted.org/packages/df/36/ed3ea2d594356fd8037e5a01f6156c74bc8d92dbb0fa60746cc96cabb6e8/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:495c302af3aad1ca67420ddd5c7bd480c8867ad173528767d906428057a11f0e", size = 5247579, upload-time = "2026-02-11T04:22:56.094Z" },
-    { url = "https://files.pythonhosted.org/packages/54/9a/9cc3e029683cf6d20ae5085da0dafc63148e3252c2f13328e553aaa13cfb/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8fd420ef0c52c88b5a035a0886f367748c72147b2b8f384c9d12656678dfdfa9", size = 6989094, upload-time = "2026-02-11T04:22:58.288Z" },
-    { url = "https://files.pythonhosted.org/packages/00/98/fc53ab36da80b88df0967896b6c4b4cd948a0dc5aa40a754266aa3ae48b3/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f975aa7ef9684ce7e2c18a3aa8f8e2106ce1e46b94ab713d156b2898811651d3", size = 5313850, upload-time = "2026-02-11T04:23:00.554Z" },
-    { url = "https://files.pythonhosted.org/packages/30/02/00fa585abfd9fe9d73e5f6e554dc36cc2b842898cbfc46d70353dae227f8/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8089c852a56c2966cf18835db62d9b34fef7ba74c726ad943928d494fa7f4735", size = 5963343, upload-time = "2026-02-11T04:23:02.934Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/26/c56ce33ca856e358d27fda9676c055395abddb82c35ac0f593877ed4562e/pillow-12.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e", size = 7029880, upload-time = "2026-02-11T04:23:04.783Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/69/a31cccd538ca0b5272be2a38347f8839b97a14be104ea08b0db92f749c74/pillow-10.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e", size = 3509271, upload-time = "2024-07-01T09:45:22.07Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9e/4143b907be8ea0bce215f2ae4f7480027473f8b61fcedfda9d851082a5d2/pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d", size = 3375658, upload-time = "2024-07-01T09:45:25.292Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/25/1fc45761955f9359b1169aa75e241551e74ac01a09f487adaaf4c3472d11/pillow-10.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856", size = 4332075, upload-time = "2024-07-01T09:45:27.94Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/dd/425b95d0151e1d6c951f45051112394f130df3da67363b6bc75dc4c27aba/pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f", size = 4444808, upload-time = "2024-07-01T09:45:30.305Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/84/9a15cc5726cbbfe7f9f90bfb11f5d028586595907cd093815ca6644932e3/pillow-10.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b", size = 4356290, upload-time = "2024-07-01T09:45:32.868Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/5b/6651c288b08df3b8c1e2f8c1152201e0b25d240e22ddade0f1e242fc9fa0/pillow-10.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc", size = 4525163, upload-time = "2024-07-01T09:45:35.279Z" },
+    { url = "https://files.pythonhosted.org/packages/07/8b/34854bf11a83c248505c8cb0fcf8d3d0b459a2246c8809b967963b6b12ae/pillow-10.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e", size = 4463100, upload-time = "2024-07-01T09:45:37.74Z" },
+    { url = "https://files.pythonhosted.org/packages/78/63/0632aee4e82476d9cbe5200c0cdf9ba41ee04ed77887432845264d81116d/pillow-10.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46", size = 4592880, upload-time = "2024-07-01T09:45:39.89Z" },
+    { url = "https://files.pythonhosted.org/packages/df/56/b8663d7520671b4398b9d97e1ed9f583d4afcbefbda3c6188325e8c297bd/pillow-10.4.0-cp310-cp310-win32.whl", hash = "sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984", size = 2235218, upload-time = "2024-07-01T09:45:42.771Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/72/0203e94a91ddb4a9d5238434ae6c1ca10e610e8487036132ea9bf806ca2a/pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141", size = 2554487, upload-time = "2024-07-01T09:45:45.176Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/52/7e7e93d7a6e4290543f17dc6f7d3af4bd0b3dd9926e2e8a35ac2282bc5f4/pillow-10.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1", size = 2243219, upload-time = "2024-07-01T09:45:47.274Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/62/c9449f9c3043c37f73e7487ec4ef0c03eb9c9afc91a92b977a67b3c0bbc5/pillow-10.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c", size = 3509265, upload-time = "2024-07-01T09:45:49.812Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/5f/491dafc7bbf5a3cc1845dc0430872e8096eb9e2b6f8161509d124594ec2d/pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be", size = 3375655, upload-time = "2024-07-01T09:45:52.462Z" },
+    { url = "https://files.pythonhosted.org/packages/73/d5/c4011a76f4207a3c151134cd22a1415741e42fa5ddecec7c0182887deb3d/pillow-10.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3", size = 4340304, upload-time = "2024-07-01T09:45:55.006Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/10/c67e20445a707f7a610699bba4fe050583b688d8cd2d202572b257f46600/pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6", size = 4452804, upload-time = "2024-07-01T09:45:58.437Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/83/6523837906d1da2b269dee787e31df3b0acb12e3d08f024965a3e7f64665/pillow-10.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe", size = 4365126, upload-time = "2024-07-01T09:46:00.713Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/e5/8c68ff608a4203085158cff5cc2a3c534ec384536d9438c405ed6370d080/pillow-10.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319", size = 4533541, upload-time = "2024-07-01T09:46:03.235Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/7c/01b8dbdca5bc6785573f4cee96e2358b0918b7b2c7b60d8b6f3abf87a070/pillow-10.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d", size = 4471616, upload-time = "2024-07-01T09:46:05.356Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/57/2899b82394a35a0fbfd352e290945440e3b3785655a03365c0ca8279f351/pillow-10.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696", size = 4600802, upload-time = "2024-07-01T09:46:08.145Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/d7/a44f193d4c26e58ee5d2d9db3d4854b2cfb5b5e08d360a5e03fe987c0086/pillow-10.4.0-cp311-cp311-win32.whl", hash = "sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496", size = 2235213, upload-time = "2024-07-01T09:46:10.211Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/d0/5866318eec2b801cdb8c82abf190c8343d8a1cd8bf5a0c17444a6f268291/pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91", size = 2554498, upload-time = "2024-07-01T09:46:12.685Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/c8/310ac16ac2b97e902d9eb438688de0d961660a87703ad1561fd3dfbd2aa0/pillow-10.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22", size = 2243219, upload-time = "2024-07-01T09:46:14.83Z" },
+    { url = "https://files.pythonhosted.org/packages/05/cb/0353013dc30c02a8be34eb91d25e4e4cf594b59e5a55ea1128fde1e5f8ea/pillow-10.4.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94", size = 3509350, upload-time = "2024-07-01T09:46:17.177Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/cf/5c558a0f247e0bf9cec92bff9b46ae6474dd736f6d906315e60e4075f737/pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597", size = 3374980, upload-time = "2024-07-01T09:46:19.169Z" },
+    { url = "https://files.pythonhosted.org/packages/84/48/6e394b86369a4eb68b8a1382c78dc092245af517385c086c5094e3b34428/pillow-10.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80", size = 4343799, upload-time = "2024-07-01T09:46:21.883Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/f3/a8c6c11fa84b59b9df0cd5694492da8c039a24cd159f0f6918690105c3be/pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca", size = 4459973, upload-time = "2024-07-01T09:46:24.321Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/1b/c14b4197b80150fb64453585247e6fb2e1d93761fa0fa9cf63b102fde822/pillow-10.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef", size = 4370054, upload-time = "2024-07-01T09:46:26.825Z" },
+    { url = "https://files.pythonhosted.org/packages/55/77/40daddf677897a923d5d33329acd52a2144d54a9644f2a5422c028c6bf2d/pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a", size = 4539484, upload-time = "2024-07-01T09:46:29.355Z" },
+    { url = "https://files.pythonhosted.org/packages/40/54/90de3e4256b1207300fb2b1d7168dd912a2fb4b2401e439ba23c2b2cabde/pillow-10.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b", size = 4477375, upload-time = "2024-07-01T09:46:31.756Z" },
+    { url = "https://files.pythonhosted.org/packages/13/24/1bfba52f44193860918ff7c93d03d95e3f8748ca1de3ceaf11157a14cf16/pillow-10.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9", size = 4608773, upload-time = "2024-07-01T09:46:33.73Z" },
+    { url = "https://files.pythonhosted.org/packages/55/04/5e6de6e6120451ec0c24516c41dbaf80cce1b6451f96561235ef2429da2e/pillow-10.4.0-cp312-cp312-win32.whl", hash = "sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42", size = 2235690, upload-time = "2024-07-01T09:46:36.587Z" },
+    { url = "https://files.pythonhosted.org/packages/74/0a/d4ce3c44bca8635bd29a2eab5aa181b654a734a29b263ca8efe013beea98/pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a", size = 2554951, upload-time = "2024-07-01T09:46:38.777Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/ca/184349ee40f2e92439be9b3502ae6cfc43ac4b50bc4fc6b3de7957563894/pillow-10.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9", size = 2243427, upload-time = "2024-07-01T09:46:43.15Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/00/706cebe7c2c12a6318aabe5d354836f54adff7156fd9e1bd6c89f4ba0e98/pillow-10.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3", size = 3525685, upload-time = "2024-07-01T09:46:45.194Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/76/f658cbfa49405e5ecbfb9ba42d07074ad9792031267e782d409fd8fe7c69/pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb", size = 3374883, upload-time = "2024-07-01T09:46:47.331Z" },
+    { url = "https://files.pythonhosted.org/packages/46/2b/99c28c4379a85e65378211971c0b430d9c7234b1ec4d59b2668f6299e011/pillow-10.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70", size = 4339837, upload-time = "2024-07-01T09:46:49.647Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/74/b1ec314f624c0c43711fdf0d8076f82d9d802afd58f1d62c2a86878e8615/pillow-10.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be", size = 4455562, upload-time = "2024-07-01T09:46:51.811Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/2a/4b04157cb7b9c74372fa867096a1607e6fedad93a44deeff553ccd307868/pillow-10.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0", size = 4366761, upload-time = "2024-07-01T09:46:53.961Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/7b/8f1d815c1a6a268fe90481232c98dd0e5fa8c75e341a75f060037bd5ceae/pillow-10.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc", size = 4536767, upload-time = "2024-07-01T09:46:56.664Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/77/05fa64d1f45d12c22c314e7b97398ffb28ef2813a485465017b7978b3ce7/pillow-10.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a", size = 4477989, upload-time = "2024-07-01T09:46:58.977Z" },
+    { url = "https://files.pythonhosted.org/packages/12/63/b0397cfc2caae05c3fb2f4ed1b4fc4fc878f0243510a7a6034ca59726494/pillow-10.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309", size = 4610255, upload-time = "2024-07-01T09:47:01.189Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/f9/cfaa5082ca9bc4a6de66ffe1c12c2d90bf09c309a5f52b27759a596900e7/pillow-10.4.0-cp313-cp313-win32.whl", hash = "sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060", size = 2235603, upload-time = "2024-07-01T09:47:03.918Z" },
+    { url = "https://files.pythonhosted.org/packages/01/6a/30ff0eef6e0c0e71e55ded56a38d4859bf9d3634a94a88743897b5f96936/pillow-10.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea", size = 2554972, upload-time = "2024-07-01T09:47:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/48/2c/2e0a52890f269435eee38b21c8218e102c621fe8d8df8b9dd06fabf879ba/pillow-10.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d", size = 2243375, upload-time = "2024-07-01T09:47:09.065Z" },
+    { url = "https://files.pythonhosted.org/packages/38/30/095d4f55f3a053392f75e2eae45eba3228452783bab3d9a920b951ac495c/pillow-10.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4", size = 3493889, upload-time = "2024-07-01T09:48:04.815Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/e8/4ff79788803a5fcd5dc35efdc9386af153569853767bff74540725b45863/pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da", size = 3346160, upload-time = "2024-07-01T09:48:07.206Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ac/4184edd511b14f760c73f5bb8a5d6fd85c591c8aff7c2229677a355c4179/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026", size = 3435020, upload-time = "2024-07-01T09:48:09.66Z" },
+    { url = "https://files.pythonhosted.org/packages/da/21/1749cd09160149c0a246a81d646e05f35041619ce76f6493d6a96e8d1103/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e", size = 3490539, upload-time = "2024-07-01T09:48:12.529Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/f5/f71fe1888b96083b3f6dfa0709101f61fc9e972c0c8d04e9d93ccef2a045/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5", size = 3476125, upload-time = "2024-07-01T09:48:14.891Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b9/c0362c54290a31866c3526848583a2f45a535aa9d725fd31e25d318c805f/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885", size = 3579373, upload-time = "2024-07-01T09:48:17.601Z" },
+    { url = "https://files.pythonhosted.org/packages/52/3b/ce7a01026a7cf46e5452afa86f97a5e88ca97f562cafa76570178ab56d8d/pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5", size = 2554661, upload-time = "2024-07-01T09:48:20.293Z" },
 ]
 
 [[package]]
@@ -5261,7 +5241,7 @@ wheels = [
 
 [[package]]
 name = "pre-commit"
-version = "4.5.1"
+version = "4.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cfgv" },
@@ -5270,9 +5250,9 @@ dependencies = [
     { name = "pyyaml" },
     { name = "virtualenv" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f4/9b/6a4ffb4ed980519da959e1cf3122fc6cb41211daa58dbae1c73c0e519a37/pre_commit-4.5.0.tar.gz", hash = "sha256:dc5a065e932b19fc1d4c653c6939068fe54325af8e741e74e88db4d28a4dd66b", size = 198428, upload-time = "2025-11-22T21:02:42.304Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/c4/b2d28e9d2edf4f1713eb3c29307f1a63f3d67cf09bdda29715a36a68921a/pre_commit-4.5.0-py2.py3-none-any.whl", hash = "sha256:25e2ce09595174d9c97860a95609f9f852c0614ba602de3561e267547f2335e1", size = 226429, upload-time = "2025-11-22T21:02:40.836Z" },
 ]
 
 [[package]]
@@ -6171,14 +6151,11 @@ wheels = [
 
 [[package]]
 name = "pypdf"
-version = "6.7.5"
+version = "4.0.2"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f6/52/37cc0aa9e9d1bf7729a737a0d83f8b3f851c8eb137373d9f71eafb0a3405/pypdf-6.7.5.tar.gz", hash = "sha256:40bb2e2e872078655f12b9b89e2f900888bb505e88a82150b64f9f34fa25651d", size = 5304278, upload-time = "2026-03-02T09:05:21.464Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5f/de/5ee74158c3090ec99eae9f90c9e9c18f207fa5c722b0e95d6fa7faebcdf8/pypdf-4.0.2.tar.gz", hash = "sha256:3316d9ddfcff5df67ae3cdfe8b945c432aa43e7f970bae7c2a4ab4fe129cd937", size = 280173, upload-time = "2024-02-18T15:45:10.729Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/05/89/336673efd0a88956562658aba4f0bbef7cb92a6fbcbcaf94926dbc82b408/pypdf-6.7.5-py3-none-any.whl", hash = "sha256:07ba7f1d6e6d9aa2a17f5452e320a84718d4ce863367f7ede2fd72280349ab13", size = 331421, upload-time = "2026-03-02T09:05:19.722Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/87/30f8a2963247fd7b1267e600379c5e3f51c9849a07d042398e4485b7415c/pypdf-4.0.2-py3-none-any.whl", hash = "sha256:a62daa2a24d5a608ba1b6284dde185317ce3644f89b9ebe5314d0c5d1c9f257d", size = 283953, upload-time = "2024-02-18T15:45:07.857Z" },
 ]
 
 [[package]]
@@ -6250,6 +6227,15 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/12/a0/d0638470df605ce266991fb04f74c69ab1bed3b90ac3838e9c3c8b69b66a/Pysher-1.0.8.tar.gz", hash = "sha256:7849c56032b208e49df67d7bd8d49029a69042ab0bb45b2ed59fa08f11ac5988", size = 9071, upload-time = "2022-10-10T13:41:09.936Z" }
 
+[[package]]
+name = "pysocks"
+version = "1.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/11/293dd436aea955d45fc4e8a35b6ae7270f5b8e00b53cf6c024c83b657a11/PySocks-1.7.1.tar.gz", hash = "sha256:3f8804571ebe159c380ac6de37643bb4685970655d3bba243530d6558b799aa0", size = 284429, upload-time = "2019-09-20T02:07:35.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/59/b4572118e098ac8e46e399a1dd0f2d85403ce8bbaad9ec79373ed6badaf9/PySocks-1.7.1-py3-none-any.whl", hash = "sha256:2725bd0a9925919b9b51739eea5f9e2bae91e83288108a9ad338b2e3a4435ee5", size = 16725, upload-time = "2019-09-20T02:06:22.938Z" },
+]
+
 [[package]]
 name = "pytest"
 version = "8.4.2"
@@ -6540,7 +6526,8 @@ dependencies = [
     { name = "portalocker" },
     { name = "protobuf" },
     { name = "pydantic" },
-    { name = "urllib3" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/1d/56/3f355f931c239c260b4fe3bd6433ec6c9e6185cd5ae0970fe89d0ca6daee/qdrant_client-1.14.3.tar.gz", hash = "sha256:bb899e3e065b79c04f5e47053d59176150c0a5dabc09d7f476c8ce8e52f4d281", size = 286766, upload-time = "2025-06-16T11:13:47.838Z" }
 wheels = [
@@ -6765,7 +6752,8 @@ dependencies = [
     { name = "certifi" },
     { name = "charset-normalizer" },
     { name = "idna" },
-    { name = "urllib3" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
 wheels = [
@@ -6933,27 +6921,28 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.15.1"
+version = "0.14.7"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/04/dc/4e6ac71b511b141cf626357a3946679abeba4cf67bc7cc5a17920f31e10d/ruff-0.15.1.tar.gz", hash = "sha256:c590fe13fb57c97141ae975c03a1aedb3d3156030cabd740d6ff0b0d601e203f", size = 4540855, upload-time = "2026-02-12T23:09:09.998Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b7/5b/dd7406afa6c95e3d8fa9d652b6d6dd17dd4a6bf63cb477014e8ccd3dcd46/ruff-0.14.7.tar.gz", hash = "sha256:3417deb75d23bd14a722b57b0a1435561db65f0ad97435b4cf9f85ffcef34ae5", size = 5727324, upload-time = "2025-11-28T20:55:10.525Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/23/bf/e6e4324238c17f9d9120a9d60aa99a7daaa21204c07fcd84e2ef03bb5fd1/ruff-0.15.1-py3-none-linux_armv6l.whl", hash = "sha256:b101ed7cf4615bda6ffe65bdb59f964e9f4a0d3f85cbf0e54f0ab76d7b90228a", size = 10367819, upload-time = "2026-02-12T23:09:03.598Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/ea/c8f89d32e7912269d38c58f3649e453ac32c528f93bb7f4219258be2e7ed/ruff-0.15.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:939c995e9277e63ea632cc8d3fae17aa758526f49a9a850d2e7e758bfef46602", size = 10798618, upload-time = "2026-02-12T23:09:22.928Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/0f/1d0d88bc862624247d82c20c10d4c0f6bb2f346559d8af281674cf327f15/ruff-0.15.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1d83466455fdefe60b8d9c8df81d3c1bbb2115cede53549d3b522ce2bc703899", size = 10148518, upload-time = "2026-02-12T23:08:58.339Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/c8/291c49cefaa4a9248e986256df2ade7add79388fe179e0691be06fae6f37/ruff-0.15.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9457e3c3291024866222b96108ab2d8265b477e5b1534c7ddb1810904858d16", size = 10518811, upload-time = "2026-02-12T23:09:31.865Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/1a/f5707440e5ae43ffa5365cac8bbb91e9665f4a883f560893829cf16a606b/ruff-0.15.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:92c92b003e9d4f7fbd33b1867bb15a1b785b1735069108dfc23821ba045b29bc", size = 10196169, upload-time = "2026-02-12T23:09:17.306Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/ff/26ddc8c4da04c8fd3ee65a89c9fb99eaa5c30394269d424461467be2271f/ruff-0.15.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fe5c41ab43e3a06778844c586251eb5a510f67125427625f9eb2b9526535779", size = 10990491, upload-time = "2026-02-12T23:09:25.503Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/00/50920cb385b89413f7cdb4bb9bc8fc59c1b0f30028d8bccc294189a54955/ruff-0.15.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66a6dd6df4d80dc382c6484f8ce1bcceb55c32e9f27a8b94c32f6c7331bf14fb", size = 11843280, upload-time = "2026-02-12T23:09:19.88Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/6d/2f5cad8380caf5632a15460c323ae326f1e1a2b5b90a6ee7519017a017ca/ruff-0.15.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a4a42cbb8af0bda9bcd7606b064d7c0bc311a88d141d02f78920be6acb5aa83", size = 11274336, upload-time = "2026-02-12T23:09:14.907Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/1d/5f56cae1d6c40b8a318513599b35ea4b075d7dc1cd1d04449578c29d1d75/ruff-0.15.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ab064052c31dddada35079901592dfba2e05f5b1e43af3954aafcbc1096a5b2", size = 11137288, upload-time = "2026-02-12T23:09:07.475Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/20/6f8d7d8f768c93b0382b33b9306b3b999918816da46537d5a61635514635/ruff-0.15.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5631c940fe9fe91f817a4c2ea4e81f47bee3ca4aa646134a24374f3c19ad9454", size = 11070681, upload-time = "2026-02-12T23:08:55.43Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/67/d640ac76069f64cdea59dba02af2e00b1fa30e2103c7f8d049c0cff4cafd/ruff-0.15.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68138a4ba184b4691ccdc39f7795c66b3c68160c586519e7e8444cf5a53e1b4c", size = 10486401, upload-time = "2026-02-12T23:09:27.927Z" },
-    { url = "https://files.pythonhosted.org/packages/65/3d/e1429f64a3ff89297497916b88c32a5cc88eeca7e9c787072d0e7f1d3e1e/ruff-0.15.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:518f9af03bfc33c03bdb4cb63fabc935341bb7f54af500f92ac309ecfbba6330", size = 10197452, upload-time = "2026-02-12T23:09:12.147Z" },
-    { url = "https://files.pythonhosted.org/packages/78/83/e2c3bade17dad63bf1e1c2ffaf11490603b760be149e1419b07049b36ef2/ruff-0.15.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:da79f4d6a826caaea95de0237a67e33b81e6ec2e25fc7e1993a4015dffca7c61", size = 10693900, upload-time = "2026-02-12T23:09:34.418Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/27/fdc0e11a813e6338e0706e8b39bb7a1d61ea5b36873b351acee7e524a72a/ruff-0.15.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3dd86dccb83cd7d4dcfac303ffc277e6048600dfc22e38158afa208e8bf94a1f", size = 11227302, upload-time = "2026-02-12T23:09:36.536Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/58/ac864a75067dcbd3b95be5ab4eb2b601d7fbc3d3d736a27e391a4f92a5c1/ruff-0.15.1-py3-none-win32.whl", hash = "sha256:660975d9cb49b5d5278b12b03bb9951d554543a90b74ed5d366b20e2c57c2098", size = 10462555, upload-time = "2026-02-12T23:09:29.899Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/5e/d4ccc8a27ecdb78116feac4935dfc39d1304536f4296168f91ed3ec00cd2/ruff-0.15.1-py3-none-win_amd64.whl", hash = "sha256:c820fef9dd5d4172a6570e5721704a96c6679b80cf7be41659ed439653f62336", size = 11599956, upload-time = "2026-02-12T23:09:01.157Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/07/5bda6a85b220c64c65686bc85bd0bbb23b29c62b3a9f9433fa55f17cda93/ruff-0.15.1-py3-none-win_arm64.whl", hash = "sha256:5ff7d5f0f88567850f45081fac8f4ec212be8d0b963e385c3f7d0d2eb4899416", size = 10874604, upload-time = "2026-02-12T23:09:05.515Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/b1/7ea5647aaf90106f6d102230e5df874613da43d1089864da1553b899ba5e/ruff-0.14.7-py3-none-linux_armv6l.whl", hash = "sha256:b9d5cb5a176c7236892ad7224bc1e63902e4842c460a0b5210701b13e3de4fca", size = 13414475, upload-time = "2025-11-28T20:54:54.569Z" },
+    { url = "https://files.pythonhosted.org/packages/af/19/fddb4cd532299db9cdaf0efdc20f5c573ce9952a11cb532d3b859d6d9871/ruff-0.14.7-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:3f64fe375aefaf36ca7d7250292141e39b4cea8250427482ae779a2aa5d90015", size = 13634613, upload-time = "2025-11-28T20:55:17.54Z" },
+    { url = "https://files.pythonhosted.org/packages/40/2b/469a66e821d4f3de0440676ed3e04b8e2a1dc7575cf6fa3ba6d55e3c8557/ruff-0.14.7-py3-none-macosx_11_0_arm64.whl", hash = "sha256:93e83bd3a9e1a3bda64cb771c0d47cda0e0d148165013ae2d3554d718632d554", size = 12765458, upload-time = "2025-11-28T20:55:26.128Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/05/0b001f734fe550bcfde4ce845948ac620ff908ab7241a39a1b39bb3c5f49/ruff-0.14.7-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3838948e3facc59a6070795de2ae16e5786861850f78d5914a03f12659e88f94", size = 13236412, upload-time = "2025-11-28T20:55:28.602Z" },
+    { url = "https://files.pythonhosted.org/packages/11/36/8ed15d243f011b4e5da75cd56d6131c6766f55334d14ba31cce5461f28aa/ruff-0.14.7-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:24c8487194d38b6d71cd0fd17a5b6715cda29f59baca1defe1e3a03240f851d1", size = 13182949, upload-time = "2025-11-28T20:55:33.265Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/cf/fcb0b5a195455729834f2a6eadfe2e4519d8ca08c74f6d2b564a4f18f553/ruff-0.14.7-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:79c73db6833f058a4be8ffe4a0913b6d4ad41f6324745179bd2aa09275b01d0b", size = 13816470, upload-time = "2025-11-28T20:55:08.203Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/5d/34a4748577ff7a5ed2f2471456740f02e86d1568a18c9faccfc73bd9ca3f/ruff-0.14.7-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:12eb7014fccff10fc62d15c79d8a6be4d0c2d60fe3f8e4d169a0d2def75f5dad", size = 15289621, upload-time = "2025-11-28T20:55:30.837Z" },
+    { url = "https://files.pythonhosted.org/packages/53/53/0a9385f047a858ba133d96f3f8e3c9c66a31cc7c4b445368ef88ebeac209/ruff-0.14.7-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c623bbdc902de7ff715a93fa3bb377a4e42dd696937bf95669118773dbf0c50", size = 14975817, upload-time = "2025-11-28T20:55:24.107Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/d7/2f1c32af54c3b46e7fadbf8006d8b9bcfbea535c316b0bd8813d6fb25e5d/ruff-0.14.7-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f53accc02ed2d200fa621593cdb3c1ae06aa9b2c3cae70bc96f72f0000ae97a9", size = 14284549, upload-time = "2025-11-28T20:55:06.08Z" },
+    { url = "https://files.pythonhosted.org/packages/92/05/434ddd86becd64629c25fb6b4ce7637dd52a45cc4a4415a3008fe61c27b9/ruff-0.14.7-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:281f0e61a23fcdcffca210591f0f53aafaa15f9025b5b3f9706879aaa8683bc4", size = 14071389, upload-time = "2025-11-28T20:55:35.617Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/50/fdf89d4d80f7f9d4f420d26089a79b3bb1538fe44586b148451bc2ba8d9c/ruff-0.14.7-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:dbbaa5e14148965b91cb090236931182ee522a5fac9bc5575bafc5c07b9f9682", size = 14202679, upload-time = "2025-11-28T20:55:01.472Z" },
+    { url = "https://files.pythonhosted.org/packages/77/54/87b34988984555425ce967f08a36df0ebd339bb5d9d0e92a47e41151eafc/ruff-0.14.7-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:1464b6e54880c0fe2f2d6eaefb6db15373331414eddf89d6b903767ae2458143", size = 13147677, upload-time = "2025-11-28T20:55:19.933Z" },
+    { url = "https://files.pythonhosted.org/packages/67/29/f55e4d44edfe053918a16a3299e758e1c18eef216b7a7092550d7a9ec51c/ruff-0.14.7-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f217ed871e4621ea6128460df57b19ce0580606c23aeab50f5de425d05226784", size = 13151392, upload-time = "2025-11-28T20:55:21.967Z" },
+    { url = "https://files.pythonhosted.org/packages/36/69/47aae6dbd4f1d9b4f7085f4d9dcc84e04561ee7ad067bf52e0f9b02e3209/ruff-0.14.7-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6be02e849440ed3602d2eb478ff7ff07d53e3758f7948a2a598829660988619e", size = 13412230, upload-time = "2025-11-28T20:55:12.749Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/4b/6e96cb6ba297f2ba502a231cd732ed7c3de98b1a896671b932a5eefa3804/ruff-0.14.7-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:19a0f116ee5e2b468dfe80c41c84e2bbd6b74f7b719bee86c2ecde0a34563bcc", size = 14195397, upload-time = "2025-11-28T20:54:56.896Z" },
+    { url = "https://files.pythonhosted.org/packages/69/82/251d5f1aa4dcad30aed491b4657cecd9fb4274214da6960ffec144c260f7/ruff-0.14.7-py3-none-win32.whl", hash = "sha256:e33052c9199b347c8937937163b9b149ef6ab2e4bb37b042e593da2e6f6cccfa", size = 13126751, upload-time = "2025-11-28T20:55:03.47Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/b5/d0b7d145963136b564806f6584647af45ab98946660d399ec4da79cae036/ruff-0.14.7-py3-none-win_amd64.whl", hash = "sha256:e17a20ad0d3fad47a326d773a042b924d3ac31c6ca6deb6c72e9e6b5f661a7c6", size = 14531726, upload-time = "2025-11-28T20:54:59.121Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/d2/1637f4360ada6a368d3265bf39f2cf737a0aaab15ab520fc005903e883f8/ruff-0.14.7-py3-none-win_arm64.whl", hash = "sha256:be4d653d3bea1b19742fcc6502354e32f65cd61ff2fbdb365803ef2c2aec6228", size = 13609215, upload-time = "2025-11-28T20:55:15.375Z" },
 ]
 
 [[package]]
@@ -7084,7 +7073,8 @@ dependencies = [
     { name = "loguru" },
     { name = "python-dateutil" },
     { name = "requests" },
-    { name = "urllib3" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/17/40/f2baf15372fba9e67c0f918ea9d753916bf875019ead972cd76e8aa0ff1b/scrapfly_sdk-0.8.24.tar.gz", hash = "sha256:84fb0a22c3df9cf3aca9bdc1ed191419e27d92a055ae70d06147ac0ced7ee654", size = 42460, upload-time = "2026-01-07T11:10:50.236Z" }
 wheels = [
@@ -7106,7 +7096,7 @@ dependencies = [
     { name = "trio", marker = "platform_python_implementation == 'PyPy'" },
     { name = "trio-websocket", marker = "platform_python_implementation == 'PyPy'" },
     { name = "typing-extensions", marker = "platform_python_implementation == 'PyPy'" },
-    { name = "urllib3", marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, extra = ["socks"], marker = "platform_python_implementation == 'PyPy'" },
     { name = "websocket-client", marker = "platform_python_implementation == 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/54/2d/fafffe946099033ccf22bf89e12eede14c1d3c5936110c5f6f2b9830722c/selenium-4.32.0.tar.gz", hash = "sha256:b9509bef4056f4083772abb1ae19ff57247d617a29255384b26be6956615b206", size = 870997, upload-time = "2025-05-02T20:35:27.325Z" }
@@ -7132,7 +7122,7 @@ dependencies = [
     { name = "types-certifi", marker = "platform_python_implementation != 'PyPy'" },
     { name = "types-urllib3", marker = "platform_python_implementation != 'PyPy'" },
     { name = "typing-extensions", marker = "platform_python_implementation != 'PyPy'" },
-    { name = "urllib3", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, extra = ["socks"], marker = "platform_python_implementation != 'PyPy'" },
     { name = "websocket-client", marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/66/ef/a5727fa7b33d20d296322adf851b76072d8d3513e1b151969d3228437faf/selenium-4.40.0.tar.gz", hash = "sha256:a88f5905d88ad0b84991c2386ea39e2bbde6d6c334be38df5842318ba98eaa8c", size = 930444, upload-time = "2026-01-18T23:12:31.565Z" }
@@ -7168,7 +7158,8 @@ version = "2.52.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
-    { name = "urllib3" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/59/eb/1b497650eb564701f9a7b8a95c51b2abe9347ed2c0b290ba78f027ebe4ea/sentry_sdk-2.52.0.tar.gz", hash = "sha256:fa0bec872cfec0302970b2996825723d67390cdd5f0229fb9efed93bd5384899", size = 410273, upload-time = "2026-02-04T15:03:54.706Z" }
 wheels = [
@@ -7327,7 +7318,6 @@ dependencies = [
     { name = "sortedcontainers" },
     { name = "tomlkit" },
     { name = "typing-extensions" },
-    { name = "urllib3" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/13/d2/4ae9fc7a0df36ad0ac06bc959757dfbfc58f160f58e1d62e7cebe9901fc7/snowflake_connector_python-4.2.0.tar.gz", hash = "sha256:74b1028caee3af4550a366ef89b33de80940bbf856844dd4d788a6b7a6511aff", size = 915327, upload-time = "2026-01-07T16:44:32.541Z" }
 wheels = [
@@ -7632,32 +7622,68 @@ wheels = [
 
 [[package]]
 name = "tokenizers"
-version = "0.22.2"
+version = "0.20.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "huggingface-hub" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", hash = "sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917", size = 372115, upload-time = "2026-01-05T10:45:15.988Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/25/b1681c1c30ea3ea6e584ae3fffd552430b12faa599b558c4c4783f56d7ff/tokenizers-0.20.3.tar.gz", hash = "sha256:2278b34c5d0dd78e087e1ca7f9b1dcbf129d80211afa645f214bd6e051037539", size = 340513, upload-time = "2024-11-05T17:34:10.403Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/92/97/5dbfabf04c7e348e655e907ed27913e03db0923abb5dfdd120d7b25630e1/tokenizers-0.22.2-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c", size = 3100275, upload-time = "2026-01-05T10:41:02.158Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/47/174dca0502ef88b28f1c9e06b73ce33500eedfac7a7692108aec220464e7/tokenizers-0.22.2-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001", size = 2981472, upload-time = "2026-01-05T10:41:00.276Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/84/7990e799f1309a8b87af6b948f31edaa12a3ed22d11b352eaf4f4b2e5753/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7", size = 3290736, upload-time = "2026-01-05T10:40:32.165Z" },
-    { url = "https://files.pythonhosted.org/packages/78/59/09d0d9ba94dcd5f4f1368d4858d24546b4bdc0231c2354aa31d6199f0399/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd", size = 3168835, upload-time = "2026-01-05T10:40:38.847Z" },
-    { url = "https://files.pythonhosted.org/packages/47/50/b3ebb4243e7160bda8d34b731e54dd8ab8b133e50775872e7a434e524c28/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5", size = 3521673, upload-time = "2026-01-05T10:40:56.614Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/fa/89f4cb9e08df770b57adb96f8cbb7e22695a4cb6c2bd5f0c4f0ebcf33b66/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e", size = 3724818, upload-time = "2026-01-05T10:40:44.507Z" },
-    { url = "https://files.pythonhosted.org/packages/64/04/ca2363f0bfbe3b3d36e95bf67e56a4c88c8e3362b658e616d1ac185d47f2/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b", size = 3379195, upload-time = "2026-01-05T10:40:51.139Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67", size = 3274982, upload-time = "2026-01-05T10:40:58.331Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/28/5f9f5a4cc211b69e89420980e483831bcc29dade307955cc9dc858a40f01/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4", size = 9478245, upload-time = "2026-01-05T10:41:04.053Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/fb/66e2da4704d6aadebf8cb39f1d6d1957df667ab24cff2326b77cda0dcb85/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a", size = 9560069, upload-time = "2026-01-05T10:45:10.673Z" },
-    { url = "https://files.pythonhosted.org/packages/16/04/fed398b05caa87ce9b1a1bb5166645e38196081b225059a6edaff6440fac/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a", size = 9899263, upload-time = "2026-01-05T10:45:12.559Z" },
-    { url = "https://files.pythonhosted.org/packages/05/a1/d62dfe7376beaaf1394917e0f8e93ee5f67fea8fcf4107501db35996586b/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5", size = 10033429, upload-time = "2026-01-05T10:45:14.333Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/18/a545c4ea42af3df6effd7d13d250ba77a0a86fb20393143bbb9a92e434d4/tokenizers-0.22.2-cp39-abi3-win32.whl", hash = "sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92", size = 2502363, upload-time = "2026-01-05T10:45:20.593Z" },
-    { url = "https://files.pythonhosted.org/packages/65/71/0670843133a43d43070abeb1949abfdef12a86d490bea9cd9e18e37c5ff7/tokenizers-0.22.2-cp39-abi3-win_amd64.whl", hash = "sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48", size = 2747786, upload-time = "2026-01-05T10:45:18.411Z" },
-    { url = "https://files.pythonhosted.org/packages/72/f4/0de46cfa12cdcbcd464cc59fde36912af405696f687e53a091fb432f694c/tokenizers-0.22.2-cp39-abi3-win_arm64.whl", hash = "sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc", size = 2612133, upload-time = "2026-01-05T10:45:17.232Z" },
-    { url = "https://files.pythonhosted.org/packages/84/04/655b79dbcc9b3ac5f1479f18e931a344af67e5b7d3b251d2dcdcd7558592/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:753d47ebd4542742ef9261d9da92cd545b2cacbb48349a1225466745bb866ec4", size = 3282301, upload-time = "2026-01-05T10:40:34.858Z" },
-    { url = "https://files.pythonhosted.org/packages/46/cd/e4851401f3d8f6f45d8480262ab6a5c8cb9c4302a790a35aa14eeed6d2fd/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e10bf9113d209be7cd046d40fbabbaf3278ff6d18eb4da4c500443185dc1896c", size = 3161308, upload-time = "2026-01-05T10:40:40.737Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/6e/55553992a89982cd12d4a66dddb5e02126c58677ea3931efcbe601d419db/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:64d94e84f6660764e64e7e0b22baa72f6cd942279fdbb21d46abd70d179f0195", size = 3718964, upload-time = "2026-01-05T10:40:46.56Z" },
-    { url = "https://files.pythonhosted.org/packages/59/8c/b1c87148aa15e099243ec9f0cf9d0e970cc2234c3257d558c25a2c5304e6/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f01a9c019878532f98927d2bacb79bbb404b43d3437455522a00a30718cdedb5", size = 3373542, upload-time = "2026-01-05T10:40:52.803Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/51/421bb0052fc4333f7c1e3231d8c6607552933d919b628c8fabd06f60ba1e/tokenizers-0.20.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:31ccab28dbb1a9fe539787210b0026e22debeab1662970f61c2d921f7557f7e4", size = 2674308, upload-time = "2024-11-05T17:30:25.423Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/e9/f651f8d27614fd59af387f4dfa568b55207e5fac8d06eec106dc00b921c4/tokenizers-0.20.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c6361191f762bda98c773da418cf511cbaa0cb8d0a1196f16f8c0119bde68ff8", size = 2559363, upload-time = "2024-11-05T17:30:28.841Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/e8/0e9f81a09ab79f409eabfd99391ca519e315496694671bebca24c3e90448/tokenizers-0.20.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f128d5da1202b78fa0a10d8d938610472487da01b57098d48f7e944384362514", size = 2892896, upload-time = "2024-11-05T17:30:30.429Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/72/15fdbc149e05005e99431ecd471807db2241983deafe1e704020f608f40e/tokenizers-0.20.3-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:79c4121a2e9433ad7ef0769b9ca1f7dd7fa4c0cd501763d0a030afcbc6384481", size = 2802785, upload-time = "2024-11-05T17:30:32.045Z" },
+    { url = "https://files.pythonhosted.org/packages/26/44/1f8aea48f9bb117d966b7272484671b33a509f6217a8e8544d79442c90db/tokenizers-0.20.3-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b7850fde24197fe5cd6556e2fdba53a6d3bae67c531ea33a3d7c420b90904141", size = 3086060, upload-time = "2024-11-05T17:30:34.11Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/83/82ba40da99870b3a0b801cffaf4f099f088a84c7e07d32cc6ca751ce08e6/tokenizers-0.20.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b357970c095dc134978a68c67d845a1e3803ab7c4fbb39195bde914e7e13cf8b", size = 3096760, upload-time = "2024-11-05T17:30:36.276Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/46/7a025404201d937f86548928616c0a164308aa3998e546efdf798bf5ee9c/tokenizers-0.20.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a333d878c4970b72d6c07848b90c05f6b045cf9273fc2bc04a27211721ad6118", size = 3380165, upload-time = "2024-11-05T17:30:37.642Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/49/15fae66ac62e49255eeedbb7f4127564b2c3f3aef2009913f525732d1a08/tokenizers-0.20.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1fd9fee817f655a8f50049f685e224828abfadd436b8ff67979fc1d054b435f1", size = 2994038, upload-time = "2024-11-05T17:30:40.075Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/64/693afc9ba2393c2eed85c02bacb44762f06a29f0d1a5591fa5b40b39c0a2/tokenizers-0.20.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9e7816808b402129393a435ea2a509679b41246175d6e5e9f25b8692bfaa272b", size = 8977285, upload-time = "2024-11-05T17:30:42.095Z" },
+    { url = "https://files.pythonhosted.org/packages/be/7e/6126c18694310fe07970717929e889898767c41fbdd95b9078e8aec0f9ef/tokenizers-0.20.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ba96367db9d8a730d3a1d5996b4b7babb846c3994b8ef14008cd8660f55db59d", size = 9294890, upload-time = "2024-11-05T17:30:44.563Z" },
+    { url = "https://files.pythonhosted.org/packages/71/7d/5e3307a1091c8608a1e58043dff49521bc19553c6e9548c7fac6840cc2c4/tokenizers-0.20.3-cp310-none-win32.whl", hash = "sha256:ee31ba9d7df6a98619426283e80c6359f167e2e9882d9ce1b0254937dbd32f3f", size = 2196883, upload-time = "2024-11-05T17:30:46.792Z" },
+    { url = "https://files.pythonhosted.org/packages/47/62/aaf5b2a526b3b10c20985d9568ff8c8f27159345eaef3347831e78cd5894/tokenizers-0.20.3-cp310-none-win_amd64.whl", hash = "sha256:a845c08fdad554fe0871d1255df85772f91236e5fd6b9287ef8b64f5807dbd0c", size = 2381637, upload-time = "2024-11-05T17:30:48.156Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/93/6742ef9206409d5ce1fdf44d5ca1687cdc3847ba0485424e2c731e6bcf67/tokenizers-0.20.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:585b51e06ca1f4839ce7759941e66766d7b060dccfdc57c4ca1e5b9a33013a90", size = 2674224, upload-time = "2024-11-05T17:30:49.972Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/14/e75ece72e99f6ef9ae07777ca9fdd78608f69466a5cecf636e9bd2f25d5c/tokenizers-0.20.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:61cbf11954f3b481d08723ebd048ba4b11e582986f9be74d2c3bdd9293a4538d", size = 2558991, upload-time = "2024-11-05T17:30:51.666Z" },
+    { url = "https://files.pythonhosted.org/packages/46/54/033b5b2ba0c3ae01e026c6f7ced147d41a2fa1c573d00a66cb97f6d7f9b3/tokenizers-0.20.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ef820880d5e4e8484e2fa54ff8d297bb32519eaa7815694dc835ace9130a3eea", size = 2892476, upload-time = "2024-11-05T17:30:53.505Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/b0/cc369fb3297d61f3311cab523d16d48c869dc2f0ba32985dbf03ff811041/tokenizers-0.20.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:67ef4dcb8841a4988cd00dd288fb95dfc8e22ed021f01f37348fd51c2b055ba9", size = 2802775, upload-time = "2024-11-05T17:30:55.229Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/74/62ad983e8ea6a63e04ed9c5be0b605056bf8aac2f0125f9b5e0b3e2b89fa/tokenizers-0.20.3-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ff1ef8bd47a02b0dc191688ccb4da53600df5d4c9a05a4b68e1e3de4823e78eb", size = 3086138, upload-time = "2024-11-05T17:30:57.332Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ac/4637ba619db25094998523f9e6f5b456e1db1f8faa770a3d925d436db0c3/tokenizers-0.20.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:444d188186eab3148baf0615b522461b41b1f0cd58cd57b862ec94b6ac9780f1", size = 3098076, upload-time = "2024-11-05T17:30:59.455Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ce/9793f2dc2ce529369807c9c74e42722b05034af411d60f5730b720388c7d/tokenizers-0.20.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:37c04c032c1442740b2c2d925f1857885c07619224a533123ac7ea71ca5713da", size = 3379650, upload-time = "2024-11-05T17:31:01.264Z" },
+    { url = "https://files.pythonhosted.org/packages/50/f6/2841de926bc4118af996eaf0bdf0ea5b012245044766ffc0347e6c968e63/tokenizers-0.20.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:453c7769d22231960ee0e883d1005c93c68015025a5e4ae56275406d94a3c907", size = 2994005, upload-time = "2024-11-05T17:31:02.985Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/b2/00915c4fed08e9505d37cf6eaab45b12b4bff8f6719d459abcb9ead86a4b/tokenizers-0.20.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4bb31f7b2847e439766aaa9cc7bccf7ac7088052deccdb2275c952d96f691c6a", size = 8977488, upload-time = "2024-11-05T17:31:04.424Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/ac/1c069e7808181ff57bcf2d39e9b6fbee9133a55410e6ebdaa89f67c32e83/tokenizers-0.20.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:843729bf0f991b29655a069a2ff58a4c24375a553c70955e15e37a90dd4e045c", size = 9294935, upload-time = "2024-11-05T17:31:06.882Z" },
+    { url = "https://files.pythonhosted.org/packages/50/47/722feb70ee68d1c4412b12d0ea4acc2713179fd63f054913990f9e259492/tokenizers-0.20.3-cp311-none-win32.whl", hash = "sha256:efcce3a927b1e20ca694ba13f7a68c59b0bd859ef71e441db68ee42cf20c2442", size = 2197175, upload-time = "2024-11-05T17:31:09.385Z" },
+    { url = "https://files.pythonhosted.org/packages/75/68/1b4f928b15a36ed278332ac75d66d7eb65d865bf344d049c452c18447bf9/tokenizers-0.20.3-cp311-none-win_amd64.whl", hash = "sha256:88301aa0801f225725b6df5dea3d77c80365ff2362ca7e252583f2b4809c4cc0", size = 2381616, upload-time = "2024-11-05T17:31:10.685Z" },
+    { url = "https://files.pythonhosted.org/packages/07/00/92a08af2a6b0c88c50f1ab47d7189e695722ad9714b0ee78ea5e1e2e1def/tokenizers-0.20.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:49d12a32e190fad0e79e5bdb788d05da2f20d8e006b13a70859ac47fecf6ab2f", size = 2667951, upload-time = "2024-11-05T17:31:12.356Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/9a/e17a352f0bffbf415cf7d73756f5c73a3219225fc5957bc2f39d52c61684/tokenizers-0.20.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:282848cacfb9c06d5e51489f38ec5aa0b3cd1e247a023061945f71f41d949d73", size = 2555167, upload-time = "2024-11-05T17:31:13.839Z" },
+    { url = "https://files.pythonhosted.org/packages/27/37/d108df55daf4f0fcf1f58554692ff71687c273d870a34693066f0847be96/tokenizers-0.20.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:abe4e08c7d0cd6154c795deb5bf81d2122f36daf075e0c12a8b050d824ef0a64", size = 2898389, upload-time = "2024-11-05T17:31:15.12Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/27/32f29da16d28f59472fa7fb38e7782069748c7e9ab9854522db20341624c/tokenizers-0.20.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ca94fc1b73b3883c98f0c88c77700b13d55b49f1071dfd57df2b06f3ff7afd64", size = 2795866, upload-time = "2024-11-05T17:31:16.857Z" },
+    { url = "https://files.pythonhosted.org/packages/29/4e/8a9a3c89e128c4a40f247b501c10279d2d7ade685953407c4d94c8c0f7a7/tokenizers-0.20.3-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef279c7e239f95c8bdd6ff319d9870f30f0d24915b04895f55b1adcf96d6c60d", size = 3085446, upload-time = "2024-11-05T17:31:18.392Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/3b/a2a7962c496ebcd95860ca99e423254f760f382cd4bd376f8895783afaf5/tokenizers-0.20.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:16384073973f6ccbde9852157a4fdfe632bb65208139c9d0c0bd0176a71fd67f", size = 3094378, upload-time = "2024-11-05T17:31:20.329Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f4/a8a33f0192a1629a3bd0afcad17d4d221bbf9276da4b95d226364208d5eb/tokenizers-0.20.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:312d522caeb8a1a42ebdec87118d99b22667782b67898a76c963c058a7e41d4f", size = 3385755, upload-time = "2024-11-05T17:31:21.778Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/65/c83cb3545a65a9eaa2e13b22c93d5e00bd7624b354a44adbdc93d5d9bd91/tokenizers-0.20.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2b7cb962564785a83dafbba0144ecb7f579f1d57d8c406cdaa7f32fe32f18ad", size = 2997679, upload-time = "2024-11-05T17:31:23.134Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e9/a80d4e592307688a67c7c59ab77e03687b6a8bd92eb5db763a2c80f93f57/tokenizers-0.20.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:124c5882ebb88dadae1fc788a582299fcd3a8bd84fc3e260b9918cf28b8751f5", size = 8989296, upload-time = "2024-11-05T17:31:24.953Z" },
+    { url = "https://files.pythonhosted.org/packages/90/af/60c957af8d2244321124e893828f1a4817cde1a2d08d09d423b73f19bd2f/tokenizers-0.20.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2b6e54e71f84c4202111a489879005cb14b92616a87417f6c102c833af961ea2", size = 9303621, upload-time = "2024-11-05T17:31:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/be/a9/96172310ee141009646d63a1ca267c099c462d747fe5ef7e33f74e27a683/tokenizers-0.20.3-cp312-none-win32.whl", hash = "sha256:83d9bfbe9af86f2d9df4833c22e94d94750f1d0cd9bfb22a7bb90a86f61cdb1c", size = 2188979, upload-time = "2024-11-05T17:31:29.483Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/68/61d85ae7ae96dde7d0974ff3538db75d5cdc29be2e4329cd7fc51a283e22/tokenizers-0.20.3-cp312-none-win_amd64.whl", hash = "sha256:44def74cee574d609a36e17c8914311d1b5dbcfe37c55fd29369d42591b91cf2", size = 2380725, upload-time = "2024-11-05T17:31:31.315Z" },
+    { url = "https://files.pythonhosted.org/packages/07/19/36e9eaafb229616cb8502b42030fa7fe347550e76cb618de71b498fc3222/tokenizers-0.20.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e0b630e0b536ef0e3c8b42c685c1bc93bd19e98c0f1543db52911f8ede42cf84", size = 2666813, upload-time = "2024-11-05T17:31:32.783Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/c7/e2ce1d4f756c8a62ef93fdb4df877c2185339b6d63667b015bf70ea9d34b/tokenizers-0.20.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a02d160d2b19bcbfdf28bd9a4bf11be4cb97d0499c000d95d4c4b1a4312740b6", size = 2555354, upload-time = "2024-11-05T17:31:34.208Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/cf/5309c2d173a6a67f9ec8697d8e710ea32418de6fd8541778032c202a1c3e/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e3d80d89b068bc30034034b5319218c7c0a91b00af19679833f55f3becb6945", size = 2897745, upload-time = "2024-11-05T17:31:35.733Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/e5/af3078e32f225e680e69d61f78855880edb8d53f5850a1834d519b2b103f/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:174a54910bed1b089226512b4458ea60d6d6fd93060254734d3bc3540953c51c", size = 2794385, upload-time = "2024-11-05T17:31:37.497Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/a7/bc421fe46650cc4eb4a913a236b88c243204f32c7480684d2f138925899e/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:098b8a632b8656aa5802c46689462c5c48f02510f24029d71c208ec2c822e771", size = 3084580, upload-time = "2024-11-05T17:31:39.456Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/22/97e1e95ee81f75922c9f569c23cb2b1fdc7f5a7a29c4c9fae17e63f751a6/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:78c8c143e3ae41e718588281eb3e212c2b31623c9d6d40410ec464d7d6221fb5", size = 3093581, upload-time = "2024-11-05T17:31:41.224Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/14/f0df0ee3b9e516121e23c0099bccd7b9f086ba9150021a750e99b16ce56f/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b26b0aadb18cd8701077362ba359a06683662d5cafe3e8e8aba10eb05c037f1", size = 3385934, upload-time = "2024-11-05T17:31:43.811Z" },
+    { url = "https://files.pythonhosted.org/packages/66/52/7a171bd4929e3ffe61a29b4340fe5b73484709f92a8162a18946e124c34c/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07d7851a72717321022f3774e84aa9d595a041d643fafa2e87fbc9b18711dac0", size = 2997311, upload-time = "2024-11-05T17:31:46.224Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/64/f1993bb8ebf775d56875ca0d50a50f2648bfbbb143da92fe2e6ceeb4abd5/tokenizers-0.20.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:bd44e48a430ada902c6266a8245f5036c4fe744fcb51f699999fbe82aa438797", size = 8988601, upload-time = "2024-11-05T17:31:47.907Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3f/49fa63422159bbc2f2a4ac5bfc597d04d4ec0ad3d2ef46649b5e9a340e37/tokenizers-0.20.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:a4c186bb006ccbe1f5cc4e0380d1ce7806f5955c244074fd96abc55e27b77f01", size = 9303950, upload-time = "2024-11-05T17:31:50.674Z" },
+    { url = "https://files.pythonhosted.org/packages/66/11/79d91aeb2817ad1993ef61c690afe73e6dbedbfb21918b302ef5a2ba9bfb/tokenizers-0.20.3-cp313-none-win32.whl", hash = "sha256:6e19e0f1d854d6ab7ea0c743d06e764d1d9a546932be0a67f33087645f00fe13", size = 2188941, upload-time = "2024-11-05T17:31:53.334Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/ff/ac8410f868fb8b14b5e619efa304aa119cb8a40bd7df29fc81a898e64f99/tokenizers-0.20.3-cp313-none-win_amd64.whl", hash = "sha256:d50ede425c7e60966a9680d41b58b3a0950afa1bb570488e2972fa61662c4273", size = 2380269, upload-time = "2024-11-05T17:31:54.796Z" },
+    { url = "https://files.pythonhosted.org/packages/29/cd/ff1586dd572aaf1637d59968df3f6f6532fa255f4638fbc29f6d27e0b690/tokenizers-0.20.3-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:e919f2e3e68bb51dc31de4fcbbeff3bdf9c1cad489044c75e2b982a91059bd3c", size = 2672044, upload-time = "2024-11-05T17:33:07.796Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/9e/7a2c00abbc8edb021ee0b1f12aab76a7b7824b49f94bcd9f075d0818d4b0/tokenizers-0.20.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b8e9608f2773996cc272156e305bd79066163a66b0390fe21750aff62df1ac07", size = 2558841, upload-time = "2024-11-05T17:33:09.542Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/c1/6af62ef61316f33ecf785bbb2bee4292f34ea62b491d4480ad9b09acf6b6/tokenizers-0.20.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39270a7050deaf50f7caff4c532c01b3c48f6608d42b3eacdebdc6795478c8df", size = 2897936, upload-time = "2024-11-05T17:33:11.413Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/0b/c076b2ff3ee6dc70c805181fbe325668b89cfee856f8dfa24cc9aa293c84/tokenizers-0.20.3-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e005466632b1c5d2d2120f6de8aa768cc9d36cd1ab7d51d0c27a114c91a1e6ee", size = 3082688, upload-time = "2024-11-05T17:33:13.538Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/60/56510124933136c2e90879e1c81603cfa753ae5a87830e3ef95056b20d8f/tokenizers-0.20.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a07962340b36189b6c8feda552ea1bfeee6cf067ff922a1d7760662c2ee229e5", size = 2998924, upload-time = "2024-11-05T17:33:16.249Z" },
+    { url = "https://files.pythonhosted.org/packages/68/60/4107b618b7b9155cb34ad2e0fc90946b7e71f041b642122fb6314f660688/tokenizers-0.20.3-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:55046ad3dd5f2b3c67501fcc8c9cbe3e901d8355f08a3b745e9b57894855f85b", size = 8989514, upload-time = "2024-11-05T17:33:18.161Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/bd/48475818e614b73316baf37ac1e4e51b578bbdf58651812d7e55f43b88d8/tokenizers-0.20.3-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:efcf0eb939988b627558aaf2b9dc3e56d759cad2e0cfa04fcab378e4b48fc4fd", size = 9303476, upload-time = "2024-11-05T17:33:21.251Z" },
 ]
 
 [[package]]
@@ -7811,7 +7837,7 @@ wheels = [
 
 [[package]]
 name = "transformers"
-version = "4.57.6"
+version = "4.46.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "filelock" },
@@ -7825,9 +7851,9 @@ dependencies = [
     { name = "tokenizers" },
     { name = "tqdm" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c4/35/67252acc1b929dc88b6602e8c4a982e64f31e733b804c14bc24b47da35e6/transformers-4.57.6.tar.gz", hash = "sha256:55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3", size = 10134912, upload-time = "2026-01-16T10:38:39.284Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/37/5a/58f96c83e566f907ae39f16d4401bbefd8bb85c60bd1e6a95c419752ab90/transformers-4.46.3.tar.gz", hash = "sha256:8ee4b3ae943fe33e82afff8e837f4b052058b07ca9be3cb5b729ed31295f72cc", size = 8627944, upload-time = "2024-11-18T22:13:01.012Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/b8/e484ef633af3887baeeb4b6ad12743363af7cce68ae51e938e00aaa0529d/transformers-4.57.6-py3-none-any.whl", hash = "sha256:4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550", size = 11993498, upload-time = "2026-01-16T10:38:31.289Z" },
+    { url = "https://files.pythonhosted.org/packages/51/51/b87caa939fedf307496e4dbf412f4b909af3d9ca8b189fc3b65c1faa456f/transformers-4.46.3-py3-none-any.whl", hash = "sha256:a12ef6f52841fd190a3e5602145b542d03507222f2c64ebb7ee92e8788093aef", size = 10034536, upload-time = "2024-11-18T22:12:57.024Z" },
 ]
 
 [[package]]
@@ -8070,11 +8096,11 @@ wheels = [
 
 [[package]]
 name = "types-regex"
-version = "2026.1.15.20260116"
+version = "2024.11.6.20250403"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c4/1a/fefad12cbe6214303d30027933a3e521188d9f283e383a183d9fda5c62fb/types_regex-2026.1.15.20260116.tar.gz", hash = "sha256:7151a9bcc5bbf9ecfccf8335c451aca8204f5a0992e0622aafaf482876cee4f7", size = 12877, upload-time = "2026-01-16T03:21:49.461Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/75/012b90c8557d3abb3b58a9073a94d211c8f75c9b2e26bf0d8af7ecf7bc78/types_regex-2024.11.6.20250403.tar.gz", hash = "sha256:3fdf2a70bbf830de4b3a28e9649a52d43dabb57cdb18fbfe2252eefb53666665", size = 12394, upload-time = "2025-04-03T02:54:35.379Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7c/d4/0d47227ea84365bea532dca287fe73cba985d6e1d3a31a71849a8aa91370/types_regex-2026.1.15.20260116-py3-none-any.whl", hash = "sha256:b20786eacbde2f2a261cbe7f5096f483da995488d196f81e585ffd2dffc555e0", size = 11099, upload-time = "2026-01-16T03:21:48.647Z" },
+    { url = "https://files.pythonhosted.org/packages/61/49/67200c4708f557be6aa4ecdb1fa212d67a10558c5240251efdc799cca22f/types_regex-2024.11.6.20250403-py3-none-any.whl", hash = "sha256:e22c0f67d73f4b4af6086a340f387b6f7d03bed8a0bb306224b75c51a29b0001", size = 10396, upload-time = "2025-04-03T02:54:34.555Z" },
 ]
 
 [[package]]
@@ -8296,15 +8322,46 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/10/6d/adb955ecf60811a3735d508974bbb5358e7745b635dc001329267529c6f2/unstructured.pytesseract-0.3.15-py3-none-any.whl", hash = "sha256:a3f505c5efb7ff9f10379051a7dd6aa624b3be6b0f023ed6767cc80d0b1613d1", size = 14992, upload-time = "2025-03-05T00:59:15.962Z" },
 ]
 
+[[package]]
+name = "urllib3"
+version = "1.26.20"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and platform_python_implementation == 'PyPy'",
+    "python_full_version == '3.11.*' and platform_python_implementation == 'PyPy'",
+    "python_full_version == '3.12.*' and platform_python_implementation == 'PyPy'",
+    "python_full_version >= '3.13' and platform_python_implementation == 'PyPy'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/e8/6ff5e6bc22095cfc59b6ea711b687e2b7ed4bdb373f7eeec370a97d7392f/urllib3-1.26.20.tar.gz", hash = "sha256:40c2dc0c681e47eb8f90e7e27bf6ff7df2e677421fd46756da1161c39ca70d32", size = 307380, upload-time = "2024-08-29T15:43:11.37Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/cf/8435d5a7159e2a9c83a95896ed596f68cf798005fe107cc655b5c5c14704/urllib3-1.26.20-py2.py3-none-any.whl", hash = "sha256:0ed14ccfbf1c30a9072c7ca157e4319b70d65f623e91e7b32fadb2853431016e", size = 144225, upload-time = "2024-08-29T15:43:08.921Z" },
+]
+
+[package.optional-dependencies]
+socks = [
+    { name = "pysocks", marker = "platform_python_implementation == 'PyPy'" },
+]
+
 [[package]]
 name = "urllib3"
 version = "2.6.3"
 source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and platform_python_implementation != 'PyPy'",
+    "python_full_version == '3.11.*' and platform_python_implementation != 'PyPy'",
+    "python_full_version == '3.12.*' and platform_python_implementation != 'PyPy'",
+    "python_full_version >= '3.13' and platform_python_implementation != 'PyPy'",
+]
 sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
 ]
 
+[package.optional-dependencies]
+socks = [
+    { name = "pysocks", marker = "platform_python_implementation != 'PyPy'" },
+]
+
 [[package]]
 name = "uuid-utils"
 version = "0.14.0"
@@ -8432,7 +8489,8 @@ version = "7.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pyyaml" },
-    { name = "urllib3" },
+    { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" },
+    { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" },
     { name = "wrapt" },
     { name = "yarl" },
 ]