fix: resolve all mypy errors across crewai package

The litellm optional dependency had a wide upper bound (<3) that allowed
any future litellm release to be installed automatically. This means
breaking changes in new litellm versions could affect customers immediately.

Pins the upper bound to <=1.82.6 (current latest known-good version).
When newer litellm versions are tested and validated, bump this bound
explicitly.

.github/workflows/pr-size.yml

@@ -0,0 +1,32 @@
+name: PR Size Check
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+jobs:
+  pr-size:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - uses: codelytv/pr-size-labeler@v1
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          xs_label: "size/XS"
+          xs_max_size: 25
+          s_label: "size/S"
+          s_max_size: 100
+          m_label: "size/M"
+          m_max_size: 250
+          l_label: "size/L"
+          l_max_size: 500
+          xl_label: "size/XL"
+          fail_if_xl: false
+          files_to_ignore: |
+            uv.lock
+            *.lock
+            lib/crewai/src/crewai/cli/templates/**
+            **/*.json
+            **/test_durations/**
+            **/cassettes/**

.github/workflows/pr-title.yml

@@ -0,0 +1,41 @@
+name: PR Title Check
+
+on:
+  pull_request:
+    types: [opened, edited, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: read
+
+jobs:
+  pr-title:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: amannn/action-semantic-pull-request@v5
+        continue-on-error: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          types: |
+            feat
+            fix
+            refactor
+            perf
+            test
+            docs
+            chore
+            ci
+            style
+            revert
+          requireScope: false
+          subjectPattern: ^[a-z].+[^.]$
+          subjectPatternError: >
+            The PR title "{title}" does not follow conventional commit format.
+
+            Expected: <type>(<scope>): <lowercase description without trailing period>
+
+            Examples:
+              feat(memory): add lancedb storage backend
+              fix(agents): resolve deadlock in concurrent execution
+              chore(deps): bump pydantic to 2.11.9

docs/en/changelog.mdx

@@ -4,6 +4,54 @@ description: "Product updates, improvements, and bug fixes for CrewAI"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="Mar 23, 2026">
+  ## v1.11.1
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.11.1)
+
+  ## What's Changed
+
+  ### Features
+  - Add flow_structure() serializer for Flow class introspection.
+
+  ### Bug Fixes
+  - Fix security vulnerabilities by bumping pypdf, tinytag, and langchain-core.
+  - Preserve full LLM config across HITL resume for non-OpenAI providers.
+  - Prevent path traversal in FileWriterTool.
+  - Fix lock_store crash when redis package is not installed.
+  - Pass cache_function from BaseTool to CrewStructuredTool.
+
+  ### Documentation
+  - Add publish custom tools guide with translations.
+  - Update changelog and version for v1.11.0.
+  - Add missing event listeners documentation.
+
+  ### Refactoring
+  - Replace urllib with requests in pdf loader.
+  - Replace Any-typed callback and model fields with serializable types.
+
+  ## Contributors
+
+  @alex-clawd, @danielfsbarreto, @dependabot[bot], @greysonlalonde, @lorenzejay, @lucasgomide, @mattatcha, @theCyberTech, @vinibrsl
+
+</Update>
+
+<Update label="Mar 18, 2026">
+  ## v1.11.0
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0)
+
+  ## What's Changed
+
+  ### Documentation
+  - Update changelog and version for v1.11.0rc2
+
+  ## Contributors
+
+  @greysonlalonde
+
+</Update>
+
 <Update label="Mar 17, 2026">
   ## v1.11.0rc2
 

docs/en/concepts/event-listener.mdx

@@ -196,12 +196,19 @@ CrewAI provides a wide range of events that you can listen for:
 - **CrewTrainStartedEvent**: Emitted when a Crew starts training
 - **CrewTrainCompletedEvent**: Emitted when a Crew completes training
 - **CrewTrainFailedEvent**: Emitted when a Crew fails to complete training
+- **CrewTestResultEvent**: Emitted when a Crew test result is available. Contains the quality score, execution duration, and model used.
 
 ### Agent Events
 
 - **AgentExecutionStartedEvent**: Emitted when an Agent starts executing a task
 - **AgentExecutionCompletedEvent**: Emitted when an Agent completes executing a task
 - **AgentExecutionErrorEvent**: Emitted when an Agent encounters an error during execution
+- **LiteAgentExecutionStartedEvent**: Emitted when a LiteAgent starts executing. Contains the agent info, tools, and messages.
+- **LiteAgentExecutionCompletedEvent**: Emitted when a LiteAgent completes execution. Contains the agent info and output.
+- **LiteAgentExecutionErrorEvent**: Emitted when a LiteAgent encounters an error during execution. Contains the agent info and error message.
+- **AgentEvaluationStartedEvent**: Emitted when an agent evaluation starts. Contains the agent ID, agent role, optional task ID, and iteration number.
+- **AgentEvaluationCompletedEvent**: Emitted when an agent evaluation completes. Contains the agent ID, agent role, optional task ID, iteration number, metric category, and score.
+- **AgentEvaluationFailedEvent**: Emitted when an agent evaluation fails. Contains the agent ID, agent role, optional task ID, iteration number, and error message.
 
 ### Task Events
 
@@ -242,16 +249,26 @@ CrewAI provides a wide range of events that you can listen for:
 
 - **LLMGuardrailStartedEvent**: Emitted when a guardrail validation starts. Contains details about the guardrail being applied and retry count.
 - **LLMGuardrailCompletedEvent**: Emitted when a guardrail validation completes. Contains details about validation success/failure, results, and error messages if any.
+- **LLMGuardrailFailedEvent**: Emitted when a guardrail validation fails. Contains the error message and retry count.
 
 ### Flow Events
 
 - **FlowCreatedEvent**: Emitted when a Flow is created
 - **FlowStartedEvent**: Emitted when a Flow starts execution
 - **FlowFinishedEvent**: Emitted when a Flow completes execution
+- **FlowPausedEvent**: Emitted when a Flow is paused waiting for human feedback. Contains the flow name, flow ID, method name, current state, message shown when requesting feedback, and optional list of possible outcomes for routing.
 - **FlowPlotEvent**: Emitted when a Flow is plotted
 - **MethodExecutionStartedEvent**: Emitted when a Flow method starts execution
 - **MethodExecutionFinishedEvent**: Emitted when a Flow method completes execution
 - **MethodExecutionFailedEvent**: Emitted when a Flow method fails to complete execution
+- **MethodExecutionPausedEvent**: Emitted when a Flow method is paused waiting for human feedback. Contains the flow name, method name, current state, flow ID, message shown when requesting feedback, and optional list of possible outcomes for routing.
+
+### Human In The Loop Events
+
+- **FlowInputRequestedEvent**: Emitted when a Flow requests user input via `Flow.ask()`. Contains the flow name, method name, the question or prompt being shown to the user, and optional metadata (e.g., user ID, channel, session context).
+- **FlowInputReceivedEvent**: Emitted when user input is received after `Flow.ask()`. Contains the flow name, method name, the original question, the user's response (or `None` if timed out), optional request metadata, and optional response metadata from the provider (e.g., who responded, thread ID, timestamps).
+- **HumanFeedbackRequestedEvent**: Emitted when a `@human_feedback` decorated method requires input from a human reviewer. Contains the flow name, method name, the method output shown to the human for review, the message displayed when requesting feedback, and optional list of possible outcomes for routing.
+- **HumanFeedbackReceivedEvent**: Emitted when a human provides feedback in response to a `@human_feedback` decorated method. Contains the flow name, method name, the raw text feedback provided by the human, and the collapsed outcome string (if emit was specified).
 
 ### LLM Events
 
@@ -259,6 +276,7 @@ CrewAI provides a wide range of events that you can listen for:
 - **LLMCallCompletedEvent**: Emitted when an LLM call completes
 - **LLMCallFailedEvent**: Emitted when an LLM call fails
 - **LLMStreamChunkEvent**: Emitted for each chunk received during streaming LLM responses
+- **LLMThinkingChunkEvent**: Emitted when a thinking/reasoning chunk is received from a thinking model. Contains the chunk text and optional response ID.
 
 ### Memory Events
 
@@ -270,6 +288,79 @@ CrewAI provides a wide range of events that you can listen for:
 - **MemorySaveFailedEvent**: Emitted when a memory save operation fails. Contains the value, metadata, agent role, and error message.
 - **MemoryRetrievalStartedEvent**: Emitted when memory retrieval for a task prompt starts. Contains the optional task ID.
 - **MemoryRetrievalCompletedEvent**: Emitted when memory retrieval for a task prompt completes successfully. Contains the task ID, memory content, and retrieval execution time.
+- **MemoryRetrievalFailedEvent**: Emitted when memory retrieval for a task prompt fails. Contains the optional task ID and error message.
+
+### Reasoning Events
+
+- **AgentReasoningStartedEvent**: Emitted when an agent starts reasoning about a task. Contains the agent role, task ID, and attempt number.
+- **AgentReasoningCompletedEvent**: Emitted when an agent finishes its reasoning process. Contains the agent role, task ID, the plan produced, and whether the agent is ready to proceed.
+- **AgentReasoningFailedEvent**: Emitted when the reasoning process fails. Contains the agent role, task ID, and error message.
+
+### Observation Events
+
+- **StepObservationStartedEvent**: Emitted when the Planner begins observing a step's result. Fires after every step execution, before the observation LLM call. Contains the agent role, step number, and step description.
+- **StepObservationCompletedEvent**: Emitted when the Planner finishes observing a step's result. Contains whether the step completed successfully, key information learned, whether the remaining plan is still valid, whether a full replan is needed, and suggested refinements.
+- **StepObservationFailedEvent**: Emitted when the observation LLM call itself fails. The system defaults to continuing the plan. Contains the error message.
+- **PlanRefinementEvent**: Emitted when the Planner refines upcoming step descriptions without a full replan. Contains the number of refined steps and the refinements applied.
+- **PlanReplanTriggeredEvent**: Emitted when the Planner triggers a full replan because the remaining plan was deemed fundamentally wrong. Contains the replan reason, replan count, and number of completed steps preserved.
+- **GoalAchievedEarlyEvent**: Emitted when the Planner detects the goal was achieved early and remaining steps will be skipped. Contains the number of steps remaining and steps completed.
+
+### A2A (Agent-to-Agent) Events
+
+#### Delegation Events
+
+- **A2ADelegationStartedEvent**: Emitted when A2A delegation starts. Contains the endpoint URL, task description, agent ID, context ID, whether it's multiturn, turn number, agent card metadata, protocol version, provider info, and optional skill ID.
+- **A2ADelegationCompletedEvent**: Emitted when A2A delegation completes. Contains the completion status (`completed`, `input_required`, `failed`, etc.), result, error message, context ID, and agent card metadata.
+- **A2AParallelDelegationStartedEvent**: Emitted when parallel delegation to multiple A2A agents begins. Contains the list of endpoints and the task description.
+- **A2AParallelDelegationCompletedEvent**: Emitted when parallel delegation to multiple A2A agents completes. Contains the list of endpoints, success count, failure count, and results summary.
+
+#### Conversation Events
+
+- **A2AConversationStartedEvent**: Emitted once at the beginning of a multiturn A2A conversation, before the first message exchange. Contains the agent ID, endpoint, context ID, agent card metadata, protocol version, and provider info.
+- **A2AMessageSentEvent**: Emitted when a message is sent to the A2A agent. Contains the message content, turn number, context ID, message ID, and whether it's multiturn.
+- **A2AResponseReceivedEvent**: Emitted when a response is received from the A2A agent. Contains the response content, turn number, context ID, message ID, status, and whether it's the final response.
+- **A2AConversationCompletedEvent**: Emitted once at the end of a multiturn A2A conversation. Contains the final status (`completed` or `failed`), final result, error message, context ID, and total number of turns.
+
+#### Streaming Events
+
+- **A2AStreamingStartedEvent**: Emitted when streaming mode begins for A2A delegation. Contains the task ID, context ID, endpoint, turn number, and whether it's multiturn.
+- **A2AStreamingChunkEvent**: Emitted when a streaming chunk is received. Contains the chunk text, chunk index, whether it's the final chunk, task ID, context ID, and turn number.
+
+#### Polling & Push Notification Events
+
+- **A2APollingStartedEvent**: Emitted when polling mode begins for A2A delegation. Contains the task ID, context ID, polling interval in seconds, and endpoint.
+- **A2APollingStatusEvent**: Emitted on each polling iteration. Contains the task ID, context ID, current task state, elapsed seconds, and poll count.
+- **A2APushNotificationRegisteredEvent**: Emitted when a push notification callback is registered. Contains the task ID, context ID, callback URL, and endpoint.
+- **A2APushNotificationReceivedEvent**: Emitted when a push notification is received from the remote A2A agent. Contains the task ID, context ID, and current state.
+- **A2APushNotificationSentEvent**: Emitted when a push notification is sent to a callback URL. Contains the task ID, context ID, callback URL, state, whether delivery succeeded, and optional error message.
+- **A2APushNotificationTimeoutEvent**: Emitted when push notification wait times out. Contains the task ID, context ID, and timeout duration in seconds.
+
+#### Connection & Authentication Events
+
+- **A2AAgentCardFetchedEvent**: Emitted when an agent card is successfully fetched. Contains the endpoint, agent name, agent card metadata, protocol version, provider info, whether it was cached, and fetch time in milliseconds.
+- **A2AAuthenticationFailedEvent**: Emitted when authentication to an A2A agent fails. Contains the endpoint, auth type attempted (e.g., `bearer`, `oauth2`, `api_key`), error message, and HTTP status code.
+- **A2AConnectionErrorEvent**: Emitted when a connection error occurs during A2A communication. Contains the endpoint, error message, error type (e.g., `timeout`, `connection_refused`, `dns_error`), HTTP status code, and the operation being attempted.
+- **A2ATransportNegotiatedEvent**: Emitted when transport protocol is negotiated with an A2A agent. Contains the negotiated transport, negotiated URL, selection source (`client_preferred`, `server_preferred`, `fallback`), and client/server supported transports.
+- **A2AContentTypeNegotiatedEvent**: Emitted when content types are negotiated with an A2A agent. Contains the client/server input/output modes, negotiated input/output modes, and whether negotiation succeeded.
+
+#### Artifact Events
+
+- **A2AArtifactReceivedEvent**: Emitted when an artifact is received from a remote A2A agent. Contains the task ID, artifact ID, artifact name, description, MIME type, size in bytes, and whether content should be appended.
+
+#### Server Task Events
+
+- **A2AServerTaskStartedEvent**: Emitted when an A2A server task execution starts. Contains the task ID and context ID.
+- **A2AServerTaskCompletedEvent**: Emitted when an A2A server task execution completes. Contains the task ID, context ID, and result.
+- **A2AServerTaskCanceledEvent**: Emitted when an A2A server task execution is canceled. Contains the task ID and context ID.
+- **A2AServerTaskFailedEvent**: Emitted when an A2A server task execution fails. Contains the task ID, context ID, and error message.
+
+#### Context Lifecycle Events
+
+- **A2AContextCreatedEvent**: Emitted when an A2A context is created. Contexts group related tasks in a conversation or workflow. Contains the context ID and creation timestamp.
+- **A2AContextExpiredEvent**: Emitted when an A2A context expires due to TTL. Contains the context ID, creation timestamp, age in seconds, and task count.
+- **A2AContextIdleEvent**: Emitted when an A2A context becomes idle (no activity for the configured threshold). Contains the context ID, idle time in seconds, and task count.
+- **A2AContextCompletedEvent**: Emitted when all tasks in an A2A context complete. Contains the context ID, total tasks, and duration in seconds.
+- **A2AContextPrunedEvent**: Emitted when an A2A context is pruned (deleted). Contains the context ID, task count, and age in seconds.
 
 ## Event Handler Structure
 

docs/en/concepts/skills.mdx

@@ -0,0 +1,115 @@
+---
+title: Skills
+description: Filesystem-based skill packages that inject context into agent prompts.
+icon: bolt
+mode: "wide"
+---
+
+## Overview
+
+Skills are self-contained directories that provide agents with domain-specific instructions, references, and assets. Each skill is defined by a `SKILL.md` file with YAML frontmatter and a markdown body.
+
+Skills use **progressive disclosure** — metadata is loaded first, full instructions only when activated, and resource catalogs only when needed.
+
+## Directory Structure
+
+```
+my-skill/
+├── SKILL.md            # Required — frontmatter + instructions
+├── scripts/            # Optional — executable scripts
+├── references/         # Optional — reference documents
+└── assets/             # Optional — static files (configs, data)
+```
+
+The directory name must match the `name` field in `SKILL.md`.
+
+## SKILL.md Format
+
+```markdown
+---
+name: my-skill
+description: Short description of what this skill does and when to use it.
+license: Apache-2.0                    # optional
+compatibility: crewai>=0.1.0          # optional
+metadata:                              # optional
+  author: your-name
+  version: "1.0"
+allowed-tools: web-search file-read   # optional, space-delimited
+---
+
+Instructions for the agent go here. This markdown body is injected
+into the agent's prompt when the skill is activated.
+```
+
+### Frontmatter Fields
+
+| Field           | Required | Constraints                                                              |
+| :-------------- | :------- | :----------------------------------------------------------------------- |
+| `name`          | Yes      | 1–64 chars. Lowercase alphanumeric and hyphens. No leading/trailing/consecutive hyphens. Must match directory name. |
+| `description`   | Yes      | 1–1024 chars. Describes what the skill does and when to use it.          |
+| `license`       | No       | License name or reference to a bundled license file.                     |
+| `compatibility` | No       | Max 500 chars. Environment requirements (products, packages, network).   |
+| `metadata`      | No       | Arbitrary string key-value mapping.                                      |
+| `allowed-tools` | No       | Space-delimited list of pre-approved tools. Experimental.                |
+
+## Usage
+
+### Agent-level Skills
+
+Pass skill directory paths to an agent:
+
+```python
+from crewai import Agent
+
+agent = Agent(
+    role="Researcher",
+    goal="Find relevant information",
+    backstory="An expert researcher.",
+    skills=["./skills"],  # discovers all skills in this directory
+)
+```
+
+### Crew-level Skills
+
+Skill paths on a crew are merged into every agent:
+
+```python
+from crewai import Crew
+
+crew = Crew(
+    agents=[agent],
+    tasks=[task],
+    skills=["./skills"],
+)
+```
+
+### Pre-loaded Skills
+
+You can also pass `Skill` objects directly:
+
+```python
+from pathlib import Path
+from crewai.skills import discover_skills, activate_skill
+
+skills = discover_skills(Path("./skills"))
+activated = [activate_skill(s) for s in skills]
+
+agent = Agent(
+    role="Researcher",
+    goal="Find relevant information",
+    backstory="An expert researcher.",
+    skills=activated,
+)
+```
+
+## How Skills Are Loaded
+
+Skills load progressively — only the data needed at each stage is read:
+
+| Stage            | What's loaded                                     | When               |
+| :--------------- | :------------------------------------------------ | :----------------- |
+| Discovery        | Name, description, frontmatter fields             | `discover_skills()` |
+| Activation       | Full SKILL.md body text                           | `activate_skill()` |
+
+During normal agent execution, skills are automatically discovered and activated. The `scripts/`, `references/`, and `assets/` directories are available on the skill's `path` for agents that need to reference files directly.
+

docs/en/guides/tools/publish-custom-tools.mdx

@@ -0,0 +1,244 @@
+---
+title: Publish Custom Tools
+description: How to build, package, and publish your own CrewAI-compatible tools to PyPI so any CrewAI user can install and use them.
+icon: box-open
+mode: "wide"
+---
+
+## Overview
+
+CrewAI's tool system is designed to be extended. If you've built a tool that could benefit others, you can package it as a standalone Python library, publish it to PyPI, and make it available to any CrewAI user — no PR to the CrewAI repo required.
+
+This guide walks through the full process: implementing the tools contract, structuring your package, and publishing to PyPI.
+
+<Note type="info" title="Not looking to publish?">
+If you just need a custom tool for your own project, see the [Create Custom Tools](/en/learn/create-custom-tools) guide instead.
+</Note>
+
+## The Tools Contract
+
+Every CrewAI tool must satisfy one of two interfaces:
+
+### Option 1: Subclass `BaseTool`
+
+Subclass `crewai.tools.BaseTool` and implement the `_run` method. Define `name`, `description`, and optionally an `args_schema` for input validation.
+
+```python
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+
+class GeolocateInput(BaseModel):
+    """Input schema for GeolocateTool."""
+    address: str = Field(..., description="The street address to geolocate.")
+
+
+class GeolocateTool(BaseTool):
+    name: str = "Geolocate"
+    description: str = "Converts a street address into latitude/longitude coordinates."
+    args_schema: type[BaseModel] = GeolocateInput
+
+    def _run(self, address: str) -> str:
+        # Your implementation here
+        return f"40.7128, -74.0060"
+```
+
+### Option 2: Use the `@tool` Decorator
+
+For simpler tools, the `@tool` decorator turns a function into a CrewAI tool. The function **must** have a docstring (used as the tool description) and type annotations.
+
+```python
+from crewai.tools import tool
+
+
+@tool("Geolocate")
+def geolocate(address: str) -> str:
+    """Converts a street address into latitude/longitude coordinates."""
+    return "40.7128, -74.0060"
+```
+
+### Key Requirements
+
+Regardless of which approach you use, your tool must:
+
+- Have a **`name`** — a short, descriptive identifier.
+- Have a **`description`** — tells the agent when and how to use the tool. This directly affects how well agents use your tool, so be clear and specific.
+- Implement **`_run`** (BaseTool) or provide a **function body** (@tool) — the synchronous execution logic.
+- Use **type annotations** on all parameters and return values.
+- Return a **string** result (or something that can be meaningfully converted to one).
+
+### Optional: Async Support
+
+If your tool performs I/O-bound work, implement `_arun` for async execution:
+
+```python
+class GeolocateTool(BaseTool):
+    name: str = "Geolocate"
+    description: str = "Converts a street address into latitude/longitude coordinates."
+
+    def _run(self, address: str) -> str:
+        # Sync implementation
+        ...
+
+    async def _arun(self, address: str) -> str:
+        # Async implementation
+        ...
+```
+
+### Optional: Input Validation with `args_schema`
+
+Define a Pydantic model as your `args_schema` to get automatic input validation and clear error messages. If you don't provide one, CrewAI will infer it from your `_run` method's signature.
+
+```python
+from pydantic import BaseModel, Field
+
+
+class TranslateInput(BaseModel):
+    """Input schema for TranslateTool."""
+    text: str = Field(..., description="The text to translate.")
+    target_language: str = Field(
+        default="en",
+        description="ISO 639-1 language code for the target language.",
+    )
+```
+
+Explicit schemas are recommended for published tools — they produce better agent behavior and clearer documentation for your users.
+
+### Optional: Environment Variables
+
+If your tool requires API keys or other configuration, declare them with `env_vars` so users know what to set:
+
+```python
+from crewai.tools import BaseTool, EnvVar
+
+
+class GeolocateTool(BaseTool):
+    name: str = "Geolocate"
+    description: str = "Converts a street address into latitude/longitude coordinates."
+    env_vars: list[EnvVar] = [
+        EnvVar(
+            name="GEOCODING_API_KEY",
+            description="API key for the geocoding service.",
+            required=True,
+        ),
+    ]
+
+    def _run(self, address: str) -> str:
+        ...
+```
+
+## Package Structure
+
+Structure your project as a standard Python package. Here's a recommended layout:
+
+```
+crewai-geolocate/
+├── pyproject.toml
+├── LICENSE
+├── README.md
+└── src/
+    └── crewai_geolocate/
+        ├── __init__.py
+        └── tools.py
+```
+
+### `pyproject.toml`
+
+```toml
+[project]
+name = "crewai-geolocate"
+version = "0.1.0"
+description = "A CrewAI tool for geolocating street addresses."
+requires-python = ">=3.10"
+dependencies = [
+    "crewai",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+```
+
+Declare `crewai` as a dependency so users get a compatible version automatically.
+
+### `__init__.py`
+
+Re-export your tool classes so users can import them directly:
+
+```python
+from crewai_geolocate.tools import GeolocateTool
+
+__all__ = ["GeolocateTool"]
+```
+
+### Naming Conventions
+
+- **Package name**: Use the prefix `crewai-` (e.g., `crewai-geolocate`). This makes your tool discoverable when users search PyPI.
+- **Module name**: Use underscores (e.g., `crewai_geolocate`).
+- **Tool class name**: Use PascalCase ending in `Tool` (e.g., `GeolocateTool`).
+
+## Testing Your Tool
+
+Before publishing, verify your tool works within a crew:
+
+```python
+from crewai import Agent, Crew, Task
+from crewai_geolocate import GeolocateTool
+
+agent = Agent(
+    role="Location Analyst",
+    goal="Find coordinates for given addresses.",
+    backstory="An expert in geospatial data.",
+    tools=[GeolocateTool()],
+)
+
+task = Task(
+    description="Find the coordinates of 1600 Pennsylvania Avenue, Washington, DC.",
+    expected_output="The latitude and longitude of the address.",
+    agent=agent,
+)
+
+crew = Crew(agents=[agent], tasks=[task])
+result = crew.kickoff()
+print(result)
+```
+
+## Publishing to PyPI
+
+Once your tool is tested and ready:
+
+```bash
+# Build the package
+uv build
+
+# Publish to PyPI
+uv publish
+```
+
+If this is your first time publishing, you'll need a [PyPI account](https://pypi.org/account/register/) and an [API token](https://pypi.org/help/#apitoken).
+
+### After Publishing
+
+Users can install your tool with:
+
+```bash
+pip install crewai-geolocate
+```
+
+Or with uv:
+
+```bash
+uv add crewai-geolocate
+```
+
+Then use it in their crews:
+
+```python
+from crewai_geolocate import GeolocateTool
+
+agent = Agent(
+    role="Location Analyst",
+    tools=[GeolocateTool()],
+    # ...
+)
+```

docs/en/learn/create-custom-tools.mdx

@@ -11,6 +11,10 @@ This guide provides detailed instructions on creating custom tools for the CrewA
 incorporating the latest functionalities such as tool delegation, error handling, and dynamic tool calling. It also highlights the importance of collaboration tools,
 enabling agents to perform a wide range of actions.
 
+<Tip>
+  **Want to publish your tool for the community?** If you're building a tool that others could benefit from, check out the [Publish Custom Tools](/en/guides/tools/publish-custom-tools) guide to learn how to package and distribute your tool on PyPI.
+</Tip>
+
 ### Subclassing `BaseTool`
 
 To create a personalized tool, inherit from `BaseTool` and define the necessary attributes, including the `args_schema` for input validation, and the `_run` method.

docs/en/learn/litellm-removal-guide.mdx

@@ -0,0 +1,358 @@
+---
+title: Using CrewAI Without LiteLLM
+description: How to use CrewAI with native provider integrations and remove the LiteLLM dependency from your project.
+icon: shield-check
+mode: "wide"
+---
+
+## Overview
+
+CrewAI supports two paths for connecting to LLM providers:
+
+1. **Native integrations** — direct SDK connections to OpenAI, Anthropic, Google Gemini, Azure OpenAI, and AWS Bedrock
+2. **LiteLLM fallback** — a translation layer that supports 100+ additional providers
+
+This guide explains how to use CrewAI exclusively with native provider integrations, removing any dependency on LiteLLM.
+
+<Warning>
+  The `litellm` package was quarantined on PyPI due to a security/reliability incident. If you rely on LiteLLM-dependent providers, you should migrate to native integrations. CrewAI's native integrations give you full functionality without LiteLLM.
+</Warning>
+
+## Why Remove LiteLLM?
+
+- **Reduced dependency surface** — fewer packages means fewer potential supply-chain risks
+- **Better performance** — native SDKs communicate directly with provider APIs, eliminating a translation layer
+- **Simpler debugging** — one less abstraction layer between your code and the provider
+- **Smaller install footprint** — LiteLLM brings in many transitive dependencies
+
+## Native Providers (No LiteLLM Required)
+
+These providers use their own SDKs and work without LiteLLM installed:
+
+<CardGroup cols={2}>
+  <Card title="OpenAI" icon="bolt">
+    GPT-4o, GPT-4o-mini, o1, o3-mini, and more.
+    ```bash
+    uv add "crewai[openai]"
+    ```
+  </Card>
+  <Card title="Anthropic" icon="a">
+    Claude Sonnet, Claude Haiku, and more.
+    ```bash
+    uv add "crewai[anthropic]"
+    ```
+  </Card>
+  <Card title="Google Gemini" icon="google">
+    Gemini 2.0 Flash, Gemini 2.0 Pro, and more.
+    ```bash
+    uv add "crewai[gemini]"
+    ```
+  </Card>
+  <Card title="Azure OpenAI" icon="microsoft">
+    Azure-hosted OpenAI models.
+    ```bash
+    uv add "crewai[azure]"
+    ```
+  </Card>
+  <Card title="AWS Bedrock" icon="aws">
+    Claude, Llama, Titan, and more via AWS.
+    ```bash
+    uv add "crewai[bedrock]"
+    ```
+  </Card>
+</CardGroup>
+
+<Info>
+  If you only use native providers, you **never** need to install `crewai[litellm]`. The base `crewai` package plus your chosen provider extra is all you need.
+</Info>
+
+## How to Check If You're Using LiteLLM
+
+### Check your model strings
+
+If your code uses model prefixes like these, you're routing through LiteLLM:
+
+| Prefix | Provider | Uses LiteLLM? |
+|--------|----------|---------------|
+| `ollama/` | Ollama | ✅ Yes |
+| `groq/` | Groq | ✅ Yes |
+| `together_ai/` | Together AI | ✅ Yes |
+| `mistral/` | Mistral | ✅ Yes |
+| `cohere/` | Cohere | ✅ Yes |
+| `huggingface/` | Hugging Face | ✅ Yes |
+| `openai/` | OpenAI | ❌ Native |
+| `anthropic/` | Anthropic | ❌ Native |
+| `gemini/` | Google Gemini | ❌ Native |
+| `azure/` | Azure OpenAI | ❌ Native |
+| `bedrock/` | AWS Bedrock | ❌ Native |
+
+### Check if LiteLLM is installed
+
+```bash
+# Using pip
+pip show litellm
+
+# Using uv
+uv pip show litellm
+```
+
+If the command returns package information, LiteLLM is installed in your environment.
+
+### Check your dependencies
+
+Look at your `pyproject.toml` for `crewai[litellm]`:
+
+```toml
+# If you see this, you have LiteLLM as a dependency
+dependencies = [
+    "crewai[litellm]>=0.100.0",  # ← Uses LiteLLM
+]
+
+# Change to a native provider extra instead
+dependencies = [
+    "crewai[openai]>=0.100.0",   # ← Native, no LiteLLM
+]
+```
+
+## Migration Guide
+
+### Step 1: Identify your current provider
+
+Find all `LLM()` calls and model strings in your code:
+
+```bash
+# Search your codebase for LLM model strings
+grep -r "LLM(" --include="*.py" .
+grep -r "llm=" --include="*.yaml" .
+grep -r "llm:" --include="*.yaml" .
+```
+
+### Step 2: Switch to a native provider
+
+<Tabs>
+  <Tab title="Switch to OpenAI">
+    ```python
+    from crewai import LLM
+
+    # Before (LiteLLM):
+    # llm = LLM(model="groq/llama-3.1-70b")
+
+    # After (Native):
+    llm = LLM(model="openai/gpt-4o")
+    ```
+
+    ```bash
+    # Install
+    uv add "crewai[openai]"
+
+    # Set your API key
+    export OPENAI_API_KEY="sk-..."
+    ```
+  </Tab>
+  <Tab title="Switch to Anthropic">
+    ```python
+    from crewai import LLM
+
+    # Before (LiteLLM):
+    # llm = LLM(model="together_ai/meta-llama/Meta-Llama-3.1-70B")
+
+    # After (Native):
+    llm = LLM(model="anthropic/claude-sonnet-4-20250514")
+    ```
+
+    ```bash
+    # Install
+    uv add "crewai[anthropic]"
+
+    # Set your API key
+    export ANTHROPIC_API_KEY="sk-ant-..."
+    ```
+  </Tab>
+  <Tab title="Switch to Gemini">
+    ```python
+    from crewai import LLM
+
+    # Before (LiteLLM):
+    # llm = LLM(model="mistral/mistral-large-latest")
+
+    # After (Native):
+    llm = LLM(model="gemini/gemini-2.0-flash")
+    ```
+
+    ```bash
+    # Install
+    uv add "crewai[gemini]"
+
+    # Set your API key
+    export GEMINI_API_KEY="..."
+    ```
+  </Tab>
+  <Tab title="Switch to Azure OpenAI">
+    ```python
+    from crewai import LLM
+
+    # After (Native):
+    llm = LLM(
+        model="azure/your-deployment-name",
+        api_key="your-azure-api-key",
+        base_url="https://your-resource.openai.azure.com",
+        api_version="2024-06-01"
+    )
+    ```
+
+    ```bash
+    # Install
+    uv add "crewai[azure]"
+    ```
+  </Tab>
+  <Tab title="Switch to AWS Bedrock">
+    ```python
+    from crewai import LLM
+
+    # After (Native):
+    llm = LLM(
+        model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
+        aws_region_name="us-east-1"
+    )
+    ```
+
+    ```bash
+    # Install
+    uv add "crewai[bedrock]"
+
+    # Configure AWS credentials
+    export AWS_ACCESS_KEY_ID="..."
+    export AWS_SECRET_ACCESS_KEY="..."
+    export AWS_DEFAULT_REGION="us-east-1"
+    ```
+  </Tab>
+</Tabs>
+
+### Step 3: Keep Ollama without LiteLLM
+
+If you're using Ollama and want to keep using it, you can connect via Ollama's OpenAI-compatible API:
+
+```python
+from crewai import LLM
+
+# Before (LiteLLM):
+# llm = LLM(model="ollama/llama3")
+
+# After (OpenAI-compatible mode, no LiteLLM needed):
+llm = LLM(
+    model="openai/llama3",
+    base_url="http://localhost:11434/v1",
+    api_key="ollama"  # Ollama doesn't require a real API key
+)
+```
+
+<Tip>
+  Many local inference servers (Ollama, vLLM, LM Studio, llama.cpp) expose an OpenAI-compatible API. You can use the `openai/` prefix with a custom `base_url` to connect to any of them natively.
+</Tip>
+
+### Step 4: Update your YAML configs
+
+```yaml
+# Before (LiteLLM providers):
+researcher:
+  role: Research Specialist
+  goal: Conduct research
+  backstory: A dedicated researcher
+  llm: groq/llama-3.1-70b          # ← LiteLLM
+  
+# After (Native provider):
+researcher:
+  role: Research Specialist
+  goal: Conduct research
+  backstory: A dedicated researcher
+  llm: openai/gpt-4o               # ← Native
+```
+
+### Step 5: Remove LiteLLM
+
+Once you've migrated all your model references:
+
+```bash
+# Remove litellm from your project
+uv remove litellm
+
+# Or if using pip
+pip uninstall litellm
+
+# Update your pyproject.toml: change crewai[litellm] to your provider extra
+# e.g., crewai[openai], crewai[anthropic], crewai[gemini]
+```
+
+### Step 6: Verify
+
+Run your project and confirm everything works:
+
+```bash
+# Run your crew
+crewai run
+
+# Or run your tests
+uv run pytest
+```
+
+## Quick Reference: Model String Mapping
+
+Here are common migration paths from LiteLLM-dependent providers to native ones:
+
+```python
+from crewai import LLM
+
+# ─── LiteLLM providers → Native alternatives ────────────────────
+
+# Groq → OpenAI or Anthropic
+# llm = LLM(model="groq/llama-3.1-70b")
+llm = LLM(model="openai/gpt-4o-mini")           # Fast & affordable
+llm = LLM(model="anthropic/claude-haiku-3-5")    # Fast & affordable
+
+# Together AI → OpenAI or Gemini
+# llm = LLM(model="together_ai/meta-llama/Meta-Llama-3.1-70B")
+llm = LLM(model="openai/gpt-4o")                 # High quality
+llm = LLM(model="gemini/gemini-2.0-flash")       # Fast & capable
+
+# Mistral → Anthropic or OpenAI
+# llm = LLM(model="mistral/mistral-large-latest")
+llm = LLM(model="anthropic/claude-sonnet-4-20250514")  # High quality
+
+# Ollama → OpenAI-compatible (keep using local models)
+# llm = LLM(model="ollama/llama3")
+llm = LLM(
+    model="openai/llama3",
+    base_url="http://localhost:11434/v1",
+    api_key="ollama"
+)
+```
+
+## FAQ
+
+<AccordionGroup>
+  <Accordion title="Do I lose any functionality by removing LiteLLM?">
+    No, if you use one of the five natively supported providers (OpenAI, Anthropic, Gemini, Azure, Bedrock). These native integrations support all CrewAI features including streaming, tool calling, structured output, and more. You only lose access to providers that are exclusively available through LiteLLM (like Groq, Together AI, Mistral as first-class providers).
+  </Accordion>
+  <Accordion title="Can I use multiple native providers at the same time?">
+    Yes. Install multiple extras and use different providers for different agents:
+    ```bash
+    uv add "crewai[openai,anthropic,gemini]"
+    ```
+    ```python
+    researcher = Agent(llm="openai/gpt-4o", ...)
+    writer = Agent(llm="anthropic/claude-sonnet-4-20250514", ...)
+    ```
+  </Accordion>
+  <Accordion title="Is LiteLLM safe to use now?">
+    Regardless of quarantine status, reducing your dependency surface is good security practice. If you only need providers that CrewAI supports natively, there's no reason to keep LiteLLM installed.
+  </Accordion>
+  <Accordion title="What about environment variables like OPENAI_API_KEY?">
+    Native providers use the same environment variables you're already familiar with. No changes needed for `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`, etc.
+  </Accordion>
+</AccordionGroup>
+
+## Related Resources
+
+- [LLM Connections](/en/learn/llm-connections) — Full guide to connecting CrewAI with any LLM
+- [LLM Concepts](/en/concepts/llms) — Understanding LLMs in CrewAI
+- [LLM Selection Guide](/en/learn/llm-selection-guide) — Choosing the right model for your use case

docs/ko/changelog.mdx

@@ -4,6 +4,54 @@ description: "CrewAI의 제품 업데이트, 개선 사항 및 버그 수정"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="2026년 3월 23일">
+  ## v1.11.1
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.11.1)
+
+  ## 변경 사항
+
+  ### 기능
+  - Flow 클래스 내성 검사를 위한 flow_structure() 직렬 변환기 추가.
+
+  ### 버그 수정
+  - pypdf, tinytag 및 langchain-core의 버전을 업데이트하여 보안 취약점 수정.
+  - 비-OpenAI 제공자의 HITL 재개 시 전체 LLM 구성 유지.
+  - FileWriterTool에서 경로 탐색 방지.
+  - redis 패키지가 설치되지 않았을 때 lock_store 충돌 수정.
+  - BaseTool에서 CrewStructuredTool로 cache_function 전달.
+
+  ### 문서화
+  - 번역이 포함된 사용자 정의 도구 게시 가이드 추가.
+  - v1.11.0에 대한 변경 로그 및 버전 업데이트.
+  - 누락된 이벤트 리스너 문서 추가.
+
+  ### 리팩토링
+  - pdf 로더에서 urllib를 requests로 교체.
+  - Any 유형의 콜백 및 모델 필드를 직렬화 가능한 유형으로 교체.
+
+  ## 기여자
+
+  @alex-clawd, @danielfsbarreto, @dependabot[bot], @greysonlalonde, @lorenzejay, @lucasgomide, @mattatcha, @theCyberTech, @vinibrsl
+
+</Update>
+
+<Update label="2026년 3월 18일">
+  ## v1.11.0
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0)
+
+  ## 변경 사항
+
+  ### 문서
+  - v1.11.0rc2에 대한 변경 로그 및 버전 업데이트
+
+  ## 기여자
+
+  @greysonlalonde
+
+</Update>
+
 <Update label="2026년 3월 17일">
   ## v1.11.0rc2
 

docs/ko/concepts/event-listener.mdx

@@ -195,12 +195,19 @@ CrewAI는 여러분이 청취할 수 있는 다양한 이벤트를 제공합니
 - **CrewTrainStartedEvent**: Crew가 훈련을 시작할 때 발생
 - **CrewTrainCompletedEvent**: Crew가 훈련을 완료할 때 발생
 - **CrewTrainFailedEvent**: Crew가 훈련을 완료하지 못할 때 발생
+- **CrewTestResultEvent**: Crew 테스트 결과가 사용 가능할 때 발생합니다. 품질 점수, 실행 시간, 사용된 모델을 포함합니다.
 
 ### 에이전트 이벤트
 
 - **AgentExecutionStartedEvent**: 에이전트가 작업 실행을 시작할 때 발생함
 - **AgentExecutionCompletedEvent**: 에이전트가 작업 실행을 완료할 때 발생함
 - **AgentExecutionErrorEvent**: 에이전트가 실행 도중 오류를 만날 때 발생함
+- **LiteAgentExecutionStartedEvent**: LiteAgent가 실행을 시작할 때 발생합니다. 에이전트 정보, 도구, 메시지를 포함합니다.
+- **LiteAgentExecutionCompletedEvent**: LiteAgent가 실행을 완료할 때 발생합니다. 에이전트 정보와 출력을 포함합니다.
+- **LiteAgentExecutionErrorEvent**: LiteAgent가 실행 중 오류를 만날 때 발생합니다. 에이전트 정보와 오류 메시지를 포함합니다.
+- **AgentEvaluationStartedEvent**: 에이전트 평가가 시작될 때 발생합니다. 에이전트 ID, 에이전트 역할, 선택적 태스크 ID, 반복 횟수를 포함합니다.
+- **AgentEvaluationCompletedEvent**: 에이전트 평가가 완료될 때 발생합니다. 에이전트 ID, 에이전트 역할, 선택적 태스크 ID, 반복 횟수, 메트릭 카테고리, 점수를 포함합니다.
+- **AgentEvaluationFailedEvent**: 에이전트 평가가 실패할 때 발생합니다. 에이전트 ID, 에이전트 역할, 선택적 태스크 ID, 반복 횟수, 오류 메시지를 포함합니다.
 
 ### 작업 이벤트
 
@@ -218,6 +225,16 @@ CrewAI는 여러분이 청취할 수 있는 다양한 이벤트를 제공합니
 - **ToolExecutionErrorEvent**: 도구 실행 중 오류가 발생할 때 발생함
 - **ToolSelectionErrorEvent**: 도구 선택 시 오류가 발생할 때 발생함
 
+### MCP 이벤트
+
+- **MCPConnectionStartedEvent**: MCP 서버 연결을 시작할 때 발생합니다. 서버 이름, URL, 전송 유형, 연결 시간 초과, 재연결 시도 여부를 포함합니다.
+- **MCPConnectionCompletedEvent**: MCP 서버에 성공적으로 연결될 때 발생합니다. 서버 이름, 연결 시간(밀리초), 재연결 여부를 포함합니다.
+- **MCPConnectionFailedEvent**: MCP 서버 연결이 실패할 때 발생합니다. 서버 이름, 오류 메시지, 오류 유형(`timeout`, `authentication`, `network` 등)을 포함합니다.
+- **MCPToolExecutionStartedEvent**: MCP 도구 실행을 시작할 때 발생합니다. 서버 이름, 도구 이름, 도구 인수를 포함합니다.
+- **MCPToolExecutionCompletedEvent**: MCP 도구 실행이 성공적으로 완료될 때 발생합니다. 서버 이름, 도구 이름, 결과, 실행 시간(밀리초)을 포함합니다.
+- **MCPToolExecutionFailedEvent**: MCP 도구 실행이 실패할 때 발생합니다. 서버 이름, 도구 이름, 오류 메시지, 오류 유형(`timeout`, `validation`, `server_error` 등)을 포함합니다.
+- **MCPConfigFetchFailedEvent**: MCP 서버 구성을 가져오는 데 실패할 때 발생합니다(예: 계정에서 MCP가 연결되지 않았거나, API 오류, 구성을 가져온 후 연결 실패). slug, 오류 메시지, 오류 유형(`not_connected`, `api_error`, `connection_failed`)을 포함합니다.
+
 ### 지식 이벤트
 
 - **KnowledgeRetrievalStartedEvent**: 지식 검색이 시작될 때 발생
@@ -231,16 +248,26 @@ CrewAI는 여러분이 청취할 수 있는 다양한 이벤트를 제공합니
 
 - **LLMGuardrailStartedEvent**: 가드레일 검증이 시작될 때 발생합니다. 적용되는 가드레일에 대한 세부 정보와 재시도 횟수를 포함합니다.
 - **LLMGuardrailCompletedEvent**: 가드레일 검증이 완료될 때 발생합니다. 검증의 성공/실패, 결과 및 오류 메시지(있는 경우)에 대한 세부 정보를 포함합니다.
+- **LLMGuardrailFailedEvent**: 가드레일 검증이 실패할 때 발생합니다. 오류 메시지와 재시도 횟수를 포함합니다.
 
 ### Flow 이벤트
 
 - **FlowCreatedEvent**: Flow가 생성될 때 발생
 - **FlowStartedEvent**: Flow가 실행을 시작할 때 발생
 - **FlowFinishedEvent**: Flow가 실행을 완료할 때 발생
+- **FlowPausedEvent**: 사람의 피드백을 기다리며 Flow가 일시 중지될 때 발생합니다. Flow 이름, Flow ID, 메서드 이름, 현재 상태, 피드백 요청 시 표시되는 메시지, 라우팅을 위한 선택적 결과 목록을 포함합니다.
 - **FlowPlotEvent**: Flow가 플롯될 때 발생
 - **MethodExecutionStartedEvent**: Flow 메서드가 실행을 시작할 때 발생
 - **MethodExecutionFinishedEvent**: Flow 메서드가 실행을 완료할 때 발생
 - **MethodExecutionFailedEvent**: Flow 메서드가 실행을 완료하지 못할 때 발생
+- **MethodExecutionPausedEvent**: 사람의 피드백을 기다리며 Flow 메서드가 일시 중지될 때 발생합니다. Flow 이름, 메서드 이름, 현재 상태, Flow ID, 피드백 요청 시 표시되는 메시지, 라우팅을 위한 선택적 결과 목록을 포함합니다.
+
+### Human In The Loop 이벤트
+
+- **FlowInputRequestedEvent**: `Flow.ask()`를 통해 Flow가 사용자 입력을 요청할 때 발생합니다. Flow 이름, 메서드 이름, 사용자에게 표시되는 질문 또는 프롬프트, 선택적 메타데이터(예: 사용자 ID, 채널, 세션 컨텍스트)를 포함합니다.
+- **FlowInputReceivedEvent**: `Flow.ask()` 이후 사용자 입력이 수신될 때 발생합니다. Flow 이름, 메서드 이름, 원래 질문, 사용자의 응답(시간 초과 시 `None`), 선택적 요청 메타데이터, 프로바이더의 선택적 응답 메타데이터(예: 응답자, 스레드 ID, 타임스탬프)를 포함합니다.
+- **HumanFeedbackRequestedEvent**: `@human_feedback` 데코레이터가 적용된 메서드가 사람 리뷰어의 입력을 필요로 할 때 발생합니다. Flow 이름, 메서드 이름, 사람에게 검토를 위해 표시되는 메서드 출력, 피드백 요청 시 표시되는 메시지, 라우팅을 위한 선택적 결과 목록을 포함합니다.
+- **HumanFeedbackReceivedEvent**: `@human_feedback` 데코레이터가 적용된 메서드에 대해 사람이 피드백을 제공할 때 발생합니다. Flow 이름, 메서드 이름, 사람이 제공한 원본 텍스트 피드백, 축약된 결과 문자열(emit이 지정된 경우)을 포함합니다.
 
 ### LLM 이벤트
 
@@ -248,6 +275,7 @@ CrewAI는 여러분이 청취할 수 있는 다양한 이벤트를 제공합니
 - **LLMCallCompletedEvent**: LLM 호출이 완료될 때 발생
 - **LLMCallFailedEvent**: LLM 호출이 실패할 때 발생
 - **LLMStreamChunkEvent**: 스트리밍 LLM 응답 중 각 청크를 받을 때마다 발생
+- **LLMThinkingChunkEvent**: thinking 모델에서 사고/추론 청크가 수신될 때 발생합니다. 청크 텍스트와 선택적 응답 ID를 포함합니다.
 
 ### 메모리 이벤트
 
@@ -259,6 +287,79 @@ CrewAI는 여러분이 청취할 수 있는 다양한 이벤트를 제공합니
 - **MemorySaveFailedEvent**: 메모리 저장 작업에 실패할 때 발생합니다. 값, 메타데이터, agent 역할, 오류 메시지를 포함합니다.
 - **MemoryRetrievalStartedEvent**: 태스크 프롬프트를 위한 메모리 검색이 시작될 때 발생합니다. 선택적 태스크 ID를 포함합니다.
 - **MemoryRetrievalCompletedEvent**: 태스크 프롬프트를 위한 메모리 검색이 성공적으로 완료될 때 발생합니다. 태스크 ID, 메모리 내용, 검색 실행 시간을 포함합니다.
+- **MemoryRetrievalFailedEvent**: 태스크 프롬프트를 위한 메모리 검색이 실패할 때 발생합니다. 선택적 태스크 ID와 오류 메시지를 포함합니다.
+
+### 추론 이벤트
+
+- **AgentReasoningStartedEvent**: 에이전트가 태스크에 대한 추론을 시작할 때 발생합니다. 에이전트 역할, 태스크 ID, 시도 횟수를 포함합니다.
+- **AgentReasoningCompletedEvent**: 에이전트가 추론 과정을 마칠 때 발생합니다. 에이전트 역할, 태스크 ID, 생성된 계획, 에이전트가 진행할 준비가 되었는지 여부를 포함합니다.
+- **AgentReasoningFailedEvent**: 추론 과정이 실패할 때 발생합니다. 에이전트 역할, 태스크 ID, 오류 메시지를 포함합니다.
+
+### 관찰 이벤트
+
+- **StepObservationStartedEvent**: Planner가 단계 결과를 관찰하기 시작할 때 발생합니다. 매 단계 실행 후, 관찰 LLM 호출 전에 발생합니다. 에이전트 역할, 단계 번호, 단계 설명을 포함합니다.
+- **StepObservationCompletedEvent**: Planner가 단계 결과 관찰을 마칠 때 발생합니다. 단계 성공 여부, 학습된 핵심 정보, 남은 계획의 유효성, 전체 재계획 필요 여부, 제안된 개선 사항을 포함합니다.
+- **StepObservationFailedEvent**: 관찰 LLM 호출 자체가 실패할 때 발생합니다. 시스템은 기본적으로 계획을 계속 진행합니다. 오류 메시지를 포함합니다.
+- **PlanRefinementEvent**: Planner가 전체 재계획 없이 다음 단계 설명을 개선할 때 발생합니다. 개선된 단계 수와 적용된 개선 사항을 포함합니다.
+- **PlanReplanTriggeredEvent**: 남은 계획이 근본적으로 잘못된 것으로 판단되어 Planner가 전체 재계획을 트리거할 때 발생합니다. 재계획 이유, 재계획 횟수, 보존된 완료 단계 수를 포함합니다.
+- **GoalAchievedEarlyEvent**: Planner가 목표가 조기에 달성되었음을 감지하고 나머지 단계를 건너뛸 때 발생합니다. 남은 단계 수와 완료된 단계 수를 포함합니다.
+
+### A2A (Agent-to-Agent) 이벤트
+
+#### 위임 이벤트
+
+- **A2ADelegationStartedEvent**: A2A 위임이 시작될 때 발생합니다. 엔드포인트 URL, 태스크 설명, 에이전트 ID, 컨텍스트 ID, 멀티턴 여부, 턴 번호, agent card 메타데이터, 프로토콜 버전, 프로바이더 정보, 선택적 skill ID를 포함합니다.
+- **A2ADelegationCompletedEvent**: A2A 위임이 완료될 때 발생합니다. 완료 상태(`completed`, `input_required`, `failed` 등), 결과, 오류 메시지, 컨텍스트 ID, agent card 메타데이터를 포함합니다.
+- **A2AParallelDelegationStartedEvent**: 여러 A2A 에이전트로의 병렬 위임이 시작될 때 발생합니다. 엔드포인트 목록과 태스크 설명을 포함합니다.
+- **A2AParallelDelegationCompletedEvent**: 여러 A2A 에이전트로의 병렬 위임이 완료될 때 발생합니다. 엔드포인트 목록, 성공 수, 실패 수, 결과 요약을 포함합니다.
+
+#### 대화 이벤트
+
+- **A2AConversationStartedEvent**: 멀티턴 A2A 대화 시작 시 한 번 발생합니다. 첫 번째 메시지 교환 전에 발생합니다. 에이전트 ID, 엔드포인트, 컨텍스트 ID, agent card 메타데이터, 프로토콜 버전, 프로바이더 정보를 포함합니다.
+- **A2AMessageSentEvent**: A2A 에이전트에 메시지가 전송될 때 발생합니다. 메시지 내용, 턴 번호, 컨텍스트 ID, 메시지 ID, 멀티턴 여부를 포함합니다.
+- **A2AResponseReceivedEvent**: A2A 에이전트로부터 응답이 수신될 때 발생합니다. 응답 내용, 턴 번호, 컨텍스트 ID, 메시지 ID, 상태, 최종 응답 여부를 포함합니다.
+- **A2AConversationCompletedEvent**: 멀티턴 A2A 대화 종료 시 한 번 발생합니다. 최종 상태(`completed` 또는 `failed`), 최종 결과, 오류 메시지, 컨텍스트 ID, 총 턴 수를 포함합니다.
+
+#### 스트리밍 이벤트
+
+- **A2AStreamingStartedEvent**: A2A 위임을 위한 스트리밍 모드가 시작될 때 발생합니다. 태스크 ID, 컨텍스트 ID, 엔드포인트, 턴 번호, 멀티턴 여부를 포함합니다.
+- **A2AStreamingChunkEvent**: 스트리밍 청크가 수신될 때 발생합니다. 청크 텍스트, 청크 인덱스, 최종 청크 여부, 태스크 ID, 컨텍스트 ID, 턴 번호를 포함합니다.
+
+#### 폴링 및 푸시 알림 이벤트
+
+- **A2APollingStartedEvent**: A2A 위임을 위한 폴링 모드가 시작될 때 발생합니다. 태스크 ID, 컨텍스트 ID, 폴링 간격(초), 엔드포인트를 포함합니다.
+- **A2APollingStatusEvent**: 각 폴링 반복 시 발생합니다. 태스크 ID, 컨텍스트 ID, 현재 태스크 상태, 경과 시간, 폴링 횟수를 포함합니다.
+- **A2APushNotificationRegisteredEvent**: 푸시 알림 콜백이 등록될 때 발생합니다. 태스크 ID, 컨텍스트 ID, 콜백 URL, 엔드포인트를 포함합니다.
+- **A2APushNotificationReceivedEvent**: 원격 A2A 에이전트로부터 푸시 알림이 수신될 때 발생합니다. 태스크 ID, 컨텍스트 ID, 현재 상태를 포함합니다.
+- **A2APushNotificationSentEvent**: 콜백 URL로 푸시 알림이 전송될 때 발생합니다. 태스크 ID, 컨텍스트 ID, 콜백 URL, 상태, 전달 성공 여부, 선택적 오류 메시지를 포함합니다.
+- **A2APushNotificationTimeoutEvent**: 푸시 알림 대기가 시간 초과될 때 발생합니다. 태스크 ID, 컨텍스트 ID, 시간 초과 시간(초)을 포함합니다.
+
+#### 연결 및 인증 이벤트
+
+- **A2AAgentCardFetchedEvent**: agent card가 성공적으로 가져올 때 발생합니다. 엔드포인트, 에이전트 이름, agent card 메타데이터, 프로토콜 버전, 프로바이더 정보, 캐시 여부, 가져오기 시간(밀리초)을 포함합니다.
+- **A2AAuthenticationFailedEvent**: A2A 에이전트 인증이 실패할 때 발생합니다. 엔드포인트, 시도된 인증 유형(예: `bearer`, `oauth2`, `api_key`), 오류 메시지, HTTP 상태 코드를 포함합니다.
+- **A2AConnectionErrorEvent**: A2A 통신 중 연결 오류가 발생할 때 발생합니다. 엔드포인트, 오류 메시지, 오류 유형(예: `timeout`, `connection_refused`, `dns_error`), HTTP 상태 코드, 시도 중인 작업을 포함합니다.
+- **A2ATransportNegotiatedEvent**: A2A 에이전트와 전송 프로토콜이 협상될 때 발생합니다. 협상된 전송, 협상된 URL, 선택 소스(`client_preferred`, `server_preferred`, `fallback`), 클라이언트/서버 지원 전송을 포함합니다.
+- **A2AContentTypeNegotiatedEvent**: A2A 에이전트와 콘텐츠 유형이 협상될 때 발생합니다. 클라이언트/서버 입출력 모드, 협상된 입출력 모드, 협상 성공 여부를 포함합니다.
+
+#### 아티팩트 이벤트
+
+- **A2AArtifactReceivedEvent**: 원격 A2A 에이전트로부터 아티팩트가 수신될 때 발생합니다. 태스크 ID, 아티팩트 ID, 아티팩트 이름, 설명, MIME 유형, 크기(바이트), 콘텐츠 추가 여부를 포함합니다.
+
+#### 서버 태스크 이벤트
+
+- **A2AServerTaskStartedEvent**: A2A 서버 태스크 실행이 시작될 때 발생합니다. 태스크 ID와 컨텍스트 ID를 포함합니다.
+- **A2AServerTaskCompletedEvent**: A2A 서버 태스크 실행이 완료될 때 발생합니다. 태스크 ID, 컨텍스트 ID, 결과를 포함합니다.
+- **A2AServerTaskCanceledEvent**: A2A 서버 태스크 실행이 취소될 때 발생합니다. 태스크 ID와 컨텍스트 ID를 포함합니다.
+- **A2AServerTaskFailedEvent**: A2A 서버 태스크 실행이 실패할 때 발생합니다. 태스크 ID, 컨텍스트 ID, 오류 메시지를 포함합니다.
+
+#### 컨텍스트 수명 주기 이벤트
+
+- **A2AContextCreatedEvent**: A2A 컨텍스트가 생성될 때 발생합니다. 컨텍스트는 대화 또는 워크플로우에서 관련 태스크를 그룹화합니다. 컨텍스트 ID와 생성 타임스탬프를 포함합니다.
+- **A2AContextExpiredEvent**: TTL로 인해 A2A 컨텍스트가 만료될 때 발생합니다. 컨텍스트 ID, 생성 타임스탬프, 수명(초), 태스크 수를 포함합니다.
+- **A2AContextIdleEvent**: A2A 컨텍스트가 유휴 상태가 될 때(설정된 임계값 동안 활동 없음) 발생합니다. 컨텍스트 ID, 유휴 시간(초), 태스크 수를 포함합니다.
+- **A2AContextCompletedEvent**: A2A 컨텍스트의 모든 태스크가 완료될 때 발생합니다. 컨텍스트 ID, 총 태스크 수, 지속 시간(초)을 포함합니다.
+- **A2AContextPrunedEvent**: A2A 컨텍스트가 정리(삭제)될 때 발생합니다. 컨텍스트 ID, 태스크 수, 수명(초)을 포함합니다.
 
 ## 이벤트 핸들러 구조
 

docs/ko/concepts/skills.mdx

@@ -0,0 +1,114 @@
+---
+title: 스킬
+description: 에이전트 프롬프트에 컨텍스트를 주입하는 파일 시스템 기반 스킬 패키지.
+icon: bolt
+mode: "wide"
+---
+
+## 개요
+
+스킬은 에이전트에게 도메인별 지침, 참조 자료, 에셋을 제공하는 자체 포함 디렉터리입니다. 각 스킬은 YAML 프론트매터와 마크다운 본문이 포함된 `SKILL.md` 파일로 정의됩니다.
+
+스킬은 **점진적 공개**를 사용합니다 — 메타데이터가 먼저 로드되고, 활성화 시에만 전체 지침이 로드되며, 필요할 때만 리소스 카탈로그가 로드됩니다.
+
+## 디렉터리 구조
+
+```
+my-skill/
+├── SKILL.md            # 필수 — 프론트매터 + 지침
+├── scripts/            # 선택 — 실행 가능한 스크립트
+├── references/         # 선택 — 참조 문서
+└── assets/             # 선택 — 정적 파일 (설정, 데이터)
+```
+
+디렉터리 이름은 `SKILL.md`의 `name` 필드와 일치해야 합니다.
+
+## SKILL.md 형식
+
+```markdown
+---
+name: my-skill
+description: 이 스킬이 무엇을 하고 언제 사용하는지에 대한 간단한 설명.
+license: Apache-2.0                    # 선택
+compatibility: crewai>=0.1.0          # 선택
+metadata:                              # 선택
+  author: your-name
+  version: "1.0"
+allowed-tools: web-search file-read   # 선택, 공백으로 구분
+---
+
+에이전트를 위한 지침이 여기에 들어갑니다. 이 마크다운 본문은
+스킬이 활성화되면 에이전트의 프롬프트에 주입됩니다.
+```
+
+### 프론트매터 필드
+
+| 필드             | 필수   | 제약 조건                                                                |
+| :-------------- | :----- | :----------------------------------------------------------------------- |
+| `name`          | 예     | 1–64자. 소문자 영숫자와 하이픈. 선행/후행/연속 하이픈 불가. 디렉터리 이름과 일치 필수. |
+| `description`   | 예     | 1–1024자. 스킬이 무엇을 하고 언제 사용하는지 설명.                          |
+| `license`       | 아니오  | 라이선스 이름 또는 번들된 라이선스 파일 참조.                                |
+| `compatibility` | 아니오  | 최대 500자. 환경 요구 사항 (제품, 패키지, 네트워크).                         |
+| `metadata`      | 아니오  | 임의의 문자열 키-값 매핑.                                                  |
+| `allowed-tools` | 아니오  | 공백으로 구분된 사전 승인 도구 목록. 실험적.                                 |
+
+## 사용법
+
+### 에이전트 레벨 스킬
+
+에이전트에 스킬 디렉터리 경로를 전달합니다:
+
+```python
+from crewai import Agent
+
+agent = Agent(
+    role="Researcher",
+    goal="Find relevant information",
+    backstory="An expert researcher.",
+    skills=["./skills"],  # 이 디렉터리의 모든 스킬을 검색
+)
+```
+
+### 크루 레벨 스킬
+
+크루의 스킬 경로는 모든 에이전트에 병합됩니다:
+
+```python
+from crewai import Crew
+
+crew = Crew(
+    agents=[agent],
+    tasks=[task],
+    skills=["./skills"],
+)
+```
+
+### 사전 로드된 스킬
+
+`Skill` 객체를 직접 전달할 수도 있습니다:
+
+```python
+from pathlib import Path
+from crewai.skills import discover_skills, activate_skill
+
+skills = discover_skills(Path("./skills"))
+activated = [activate_skill(s) for s in skills]
+
+agent = Agent(
+    role="Researcher",
+    goal="Find relevant information",
+    backstory="An expert researcher.",
+    skills=activated,
+)
+```
+
+## 스킬 로드 방식
+
+스킬은 점진적으로 로드됩니다 — 각 단계에서 필요한 데이터만 읽습니다:
+
+| 단계              | 로드되는 내용                                      | 시점                |
+| :--------------- | :------------------------------------------------ | :----------------- |
+| 검색              | 이름, 설명, 프론트매터 필드                          | `discover_skills()` |
+| 활성화            | 전체 SKILL.md 본문 텍스트                           | `activate_skill()` |
+
+일반적인 에이전트 실행 중에 스킬은 자동으로 검색되고 활성화됩니다. `scripts/`, `references/`, `assets/` 디렉터리는 파일을 직접 참조해야 하는 에이전트를 위해 스킬의 `path`에서 사용할 수 있습니다.

docs/ko/guides/coding-tools/agents-md.mdx

@@ -0,0 +1,61 @@
+---
+title: 코딩 도구
+description: AGENTS.md를 사용하여 CrewAI 프로젝트 전반에서 코딩 에이전트와 IDE를 안내합니다.
+icon: terminal
+mode: "wide"
+---
+
+## AGENTS.md를 사용하는 이유
+
+`AGENTS.md`는 가벼운 저장소 로컬 지침 파일로, 코딩 에이전트에게 일관되고 프로젝트별 안내를 제공합니다. 프로젝트 루트에 배치하고 어시스턴트가 작업하는 방식(컨벤션, 명령어, 아키텍처 노트, 가드레일)에 대한 신뢰할 수 있는 소스로 활용하세요.
+
+## CLI로 프로젝트 생성
+
+CrewAI CLI를 사용하여 프로젝트를 스캐폴딩하면, `AGENTS.md`가 루트에 자동으로 추가됩니다.
+
+```bash
+# Crew
+crewai create crew my_crew
+
+# Flow
+crewai create flow my_flow
+
+# Tool repository
+crewai tool create my_tool
+```
+
+## 도구 설정: 어시스턴트에 AGENTS.md 연결
+
+### Codex
+
+Codex는 저장소에 배치된 `AGENTS.md` 파일로 안내할 수 있습니다. 컨벤션, 명령어, 워크플로우 기대치 등 지속적인 프로젝트 컨텍스트를 제공하는 데 사용하세요.
+
+### Claude Code
+
+Claude Code는 프로젝트 메모리를 `CLAUDE.md`에 저장합니다. `/init`으로 부트스트랩하고 `/memory`로 편집할 수 있습니다. Claude Code는 `CLAUDE.md` 내에서 임포트도 지원하므로, `@AGENTS.md`와 같은 한 줄을 추가하여 공유 지침을 중복 없이 가져올 수 있습니다.
+
+간단하게 다음과 같이 사용할 수 있습니다:
+
+```bash
+mv AGENTS.md CLAUDE.md
+```
+
+### Gemini CLI와 Google Antigravity
+
+Gemini CLI와 Antigravity는 저장소 루트 및 상위 디렉토리에서 프로젝트 컨텍스트 파일(기본값: `GEMINI.md`)을 로드합니다. Gemini CLI 설정에서 `context.fileName`을 설정하여 `AGENTS.md`를 대신(또는 추가로) 읽도록 구성할 수 있습니다. 예를 들어, `AGENTS.md`만 설정하거나 각 도구의 형식을 유지하고 싶다면 `AGENTS.md`와 `GEMINI.md`를 모두 포함할 수 있습니다.
+
+간단하게 다음과 같이 사용할 수 있습니다:
+
+```bash
+mv AGENTS.md GEMINI.md
+```
+
+### Cursor
+
+Cursor는 `AGENTS.md`를 프로젝트 지침 파일로 지원합니다. 프로젝트 루트에 배치하여 Cursor의 코딩 어시스턴트에 안내를 제공하세요.
+
+### Windsurf
+
+Claude Code는 Windsurf와의 공식 통합을 제공합니다. Windsurf 내에서 Claude Code를 사용하는 경우, 위의 Claude Code 안내를 따르고 `CLAUDE.md`에서 `AGENTS.md`를 임포트하세요.
+
+Windsurf의 네이티브 어시스턴트를 사용하는 경우, 프로젝트 규칙 또는 지침 기능(사용 가능한 경우)을 구성하여 `AGENTS.md`에서 읽거나 내용을 직접 붙여넣으세요.

docs/ko/guides/tools/publish-custom-tools.mdx

@@ -0,0 +1,244 @@
+---
+title: 커스텀 도구 배포하기
+description: PyPI에 게시할 수 있는 CrewAI 호환 도구를 빌드, 패키징, 배포하는 방법을 안내합니다.
+icon: box-open
+mode: "wide"
+---
+
+## 개요
+
+CrewAI의 도구 시스템은 확장 가능하도록 설계되었습니다. 다른 사용자에게도 유용한 도구를 만들었다면, 독립적인 Python 라이브러리로 패키징하여 PyPI에 게시하고 모든 CrewAI 사용자가 사용할 수 있도록 할 수 있습니다. CrewAI 저장소에 PR을 보낼 필요가 없습니다.
+
+이 가이드에서는 도구 계약 구현, 패키지 구조화, PyPI 게시까지의 전체 과정을 안내합니다.
+
+<Note type="info" title="배포할 계획이 없으신가요?">
+프로젝트 내에서만 사용할 커스텀 도구가 필요하다면 [커스텀 도구 생성](/ko/learn/create-custom-tools) 가이드를 참고하세요.
+</Note>
+
+## 도구 계약
+
+모든 CrewAI 도구는 다음 두 가지 인터페이스 중 하나를 충족해야 합니다:
+
+### 옵션 1: `BaseTool` 서브클래싱
+
+`crewai.tools.BaseTool`을 서브클래싱하고 `_run` 메서드를 구현합니다. `name`, `description`, 그리고 선택적으로 입력 검증을 위한 `args_schema`를 정의합니다.
+
+```python
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+
+class GeolocateInput(BaseModel):
+    """GeolocateTool의 입력 스키마."""
+    address: str = Field(..., description="지오코딩할 도로명 주소.")
+
+
+class GeolocateTool(BaseTool):
+    name: str = "Geolocate"
+    description: str = "도로명 주소를 위도/경도 좌표로 변환합니다."
+    args_schema: type[BaseModel] = GeolocateInput
+
+    def _run(self, address: str) -> str:
+        # 구현 로직
+        return f"40.7128, -74.0060"
+```
+
+### 옵션 2: `@tool` 데코레이터 사용
+
+간단한 도구의 경우, `@tool` 데코레이터로 함수를 CrewAI 도구로 변환할 수 있습니다. 함수에는 반드시 독스트링(도구 설명으로 사용됨)과 타입 어노테이션이 있어야 합니다.
+
+```python
+from crewai.tools import tool
+
+
+@tool("Geolocate")
+def geolocate(address: str) -> str:
+    """도로명 주소를 위도/경도 좌표로 변환합니다."""
+    return "40.7128, -74.0060"
+```
+
+### 핵심 요구사항
+
+어떤 방식을 사용하든, 도구는 다음을 충족해야 합니다:
+
+- **`name`** — 짧고 설명적인 식별자.
+- **`description`** — 에이전트에게 도구를 언제, 어떻게 사용할지 알려줍니다. 에이전트가 도구를 얼마나 잘 활용하는지에 직접적으로 영향을 미치므로 명확하고 구체적으로 작성하세요.
+- **`_run`** (BaseTool) 또는 **함수 본문** (@tool) 구현 — 동기 실행 로직.
+- 모든 매개변수와 반환 값에 **타입 어노테이션** 사용.
+- **문자열** 결과를 반환 (또는 의미 있게 문자열로 변환 가능한 값).
+
+### 선택사항: 비동기 지원
+
+I/O 바운드 작업을 수행하는 도구의 경우 비동기 실행을 위해 `_arun`을 구현합니다:
+
+```python
+class GeolocateTool(BaseTool):
+    name: str = "Geolocate"
+    description: str = "도로명 주소를 위도/경도 좌표로 변환합니다."
+
+    def _run(self, address: str) -> str:
+        # 동기 구현
+        ...
+
+    async def _arun(self, address: str) -> str:
+        # 비동기 구현
+        ...
+```
+
+### 선택사항: `args_schema`를 통한 입력 검증
+
+Pydantic 모델을 `args_schema`로 정의하면 자동 입력 검증과 명확한 에러 메시지를 받을 수 있습니다. 제공하지 않으면 CrewAI가 `_run` 메서드의 시그니처에서 추론합니다.
+
+```python
+from pydantic import BaseModel, Field
+
+
+class TranslateInput(BaseModel):
+    """TranslateTool의 입력 스키마."""
+    text: str = Field(..., description="번역할 텍스트.")
+    target_language: str = Field(
+        default="en",
+        description="대상 언어의 ISO 639-1 언어 코드.",
+    )
+```
+
+배포용 도구에는 명시적 스키마를 권장합니다 — 에이전트 동작이 개선되고 사용자에게 더 명확한 문서를 제공합니다.
+
+### 선택사항: 환경 변수
+
+도구에 API 키나 기타 설정이 필요한 경우, `env_vars`로 선언하여 사용자가 무엇을 설정해야 하는지 알 수 있도록 합니다:
+
+```python
+from crewai.tools import BaseTool, EnvVar
+
+
+class GeolocateTool(BaseTool):
+    name: str = "Geolocate"
+    description: str = "도로명 주소를 위도/경도 좌표로 변환합니다."
+    env_vars: list[EnvVar] = [
+        EnvVar(
+            name="GEOCODING_API_KEY",
+            description="지오코딩 서비스 API 키.",
+            required=True,
+        ),
+    ]
+
+    def _run(self, address: str) -> str:
+        ...
+```
+
+## 패키지 구조
+
+프로젝트를 표준 Python 패키지로 구성합니다. 권장 레이아웃:
+
+```
+crewai-geolocate/
+├── pyproject.toml
+├── LICENSE
+├── README.md
+└── src/
+    └── crewai_geolocate/
+        ├── __init__.py
+        └── tools.py
+```
+
+### `pyproject.toml`
+
+```toml
+[project]
+name = "crewai-geolocate"
+version = "0.1.0"
+description = "도로명 주소를 지오코딩하는 CrewAI 도구."
+requires-python = ">=3.10"
+dependencies = [
+    "crewai",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+```
+
+사용자가 자동으로 호환 버전을 받을 수 있도록 `crewai`를 의존성으로 선언합니다.
+
+### `__init__.py`
+
+사용자가 직접 import할 수 있도록 도구 클래스를 re-export합니다:
+
+```python
+from crewai_geolocate.tools import GeolocateTool
+
+__all__ = ["GeolocateTool"]
+```
+
+### 명명 규칙
+
+- **패키지 이름**: `crewai-` 접두사를 사용합니다 (예: `crewai-geolocate`). PyPI에서 검색할 때 도구를 쉽게 찾을 수 있습니다.
+- **모듈 이름**: 밑줄을 사용합니다 (예: `crewai_geolocate`).
+- **도구 클래스 이름**: `Tool`로 끝나는 PascalCase를 사용합니다 (예: `GeolocateTool`).
+
+## 도구 테스트
+
+게시 전에 도구가 크루 내에서 작동하는지 확인합니다:
+
+```python
+from crewai import Agent, Crew, Task
+from crewai_geolocate import GeolocateTool
+
+agent = Agent(
+    role="Location Analyst",
+    goal="주어진 주소의 좌표를 찾습니다.",
+    backstory="지리공간 데이터 전문가.",
+    tools=[GeolocateTool()],
+)
+
+task = Task(
+    description="1600 Pennsylvania Avenue, Washington, DC의 좌표를 찾으세요.",
+    expected_output="해당 주소의 위도와 경도.",
+    agent=agent,
+)
+
+crew = Crew(agents=[agent], tasks=[task])
+result = crew.kickoff()
+print(result)
+```
+
+## PyPI에 게시하기
+
+도구 테스트를 완료하고 준비가 되면:
+
+```bash
+# 패키지 빌드
+uv build
+
+# PyPI에 게시
+uv publish
+```
+
+처음 게시하는 경우 [PyPI 계정](https://pypi.org/account/register/)과 [API 토큰](https://pypi.org/help/#apitoken)이 필요합니다.
+
+### 게시 후
+
+사용자는 다음과 같이 도구를 설치할 수 있습니다:
+
+```bash
+pip install crewai-geolocate
+```
+
+또는 uv를 사용하여:
+
+```bash
+uv add crewai-geolocate
+```
+
+그런 다음 크루에서 사용합니다:
+
+```python
+from crewai_geolocate import GeolocateTool
+
+agent = Agent(
+    role="Location Analyst",
+    tools=[GeolocateTool()],
+    # ...
+)
+```

docs/ko/learn/create-custom-tools.mdx

@@ -9,6 +9,10 @@ mode: "wide"
 
 이 가이드는 CrewAI 프레임워크를 위한 커스텀 툴을 생성하는 방법과 최신 기능(툴 위임, 오류 처리, 동적 툴 호출 등)을 통합하여 이러한 툴을 효율적으로 관리하고 활용하는 방법에 대해 자세히 안내합니다. 또한 협업 툴의 중요성을 강조하며, 에이전트가 다양한 작업을 수행할 수 있도록 지원합니다.
 
+<Tip>
+  **커뮤니티에 도구를 배포하고 싶으신가요?** 다른 사용자에게도 유용한 도구를 만들고 있다면, [커스텀 도구 배포하기](/ko/guides/tools/publish-custom-tools) 가이드에서 도구를 패키징하고 PyPI에 배포하는 방법을 알아보세요.
+</Tip>
+
 ### `BaseTool` 서브클래싱
 
 개인화된 툴을 생성하려면 `BaseTool`을 상속받고, 입력 검증을 위한 `args_schema`와 `_run` 메서드를 포함한 필요한 속성들을 정의해야 합니다.

docs/pt-BR/changelog.mdx

@@ -4,6 +4,54 @@ description: "Atualizações de produto, melhorias e correções do CrewAI"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="23 mar 2026">
+  ## v1.11.1
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.11.1)
+
+  ## O que Mudou
+
+  ### Funcionalidades
+  - Adicionar o serializer flow_structure() para introspecção da classe Flow.
+
+  ### Correções de Bugs
+  - Corrigir vulnerabilidades de segurança atualizando pypdf, tinytag e langchain-core.
+  - Preservar a configuração completa do LLM durante a retomada do HITL para provedores que não são da OpenAI.
+  - Prevenir a travessia de caminho no FileWriterTool.
+  - Corrigir a falha do lock_store quando o pacote redis não está instalado.
+  - Passar cache_function de BaseTool para CrewStructuredTool.
+
+  ### Documentação
+  - Adicionar guia de publicação de ferramentas personalizadas com traduções.
+  - Atualizar changelog e versão para v1.11.0.
+  - Adicionar documentação de ouvintes de eventos ausentes.
+
+  ### Refatoração
+  - Substituir urllib por requests no carregador de pdf.
+  - Substituir campos de callback e modelo do tipo Any por tipos serializáveis.
+
+  ## Contribuidores
+
+  @alex-clawd, @danielfsbarreto, @dependabot[bot], @greysonlalonde, @lorenzejay, @lucasgomide, @mattatcha, @theCyberTech, @vinibrsl
+
+</Update>
+
+<Update label="18 mar 2026">
+  ## v1.11.0
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0)
+
+  ## O que Mudou
+
+  ### Documentação
+  - Atualizar changelog e versão para v1.11.0rc2
+
+  ## Contribuidores
+
+  @greysonlalonde
+
+</Update>
+
 <Update label="17 mar 2026">
   ## v1.11.0rc2
 

docs/pt-BR/concepts/event-listener.mdx

@@ -196,12 +196,19 @@ O CrewAI fornece uma ampla variedade de eventos para escuta:
 - **CrewTrainStartedEvent**: Emitido ao iniciar o treinamento de um Crew
 - **CrewTrainCompletedEvent**: Emitido ao concluir o treinamento de um Crew
 - **CrewTrainFailedEvent**: Emitido ao falhar no treinamento de um Crew
+- **CrewTestResultEvent**: Emitido quando um resultado de teste de Crew está disponível. Contém a pontuação de qualidade, duração da execução e modelo utilizado.
 
 ### Eventos de Agent
 
 - **AgentExecutionStartedEvent**: Emitido quando um Agent inicia a execução de uma tarefa
 - **AgentExecutionCompletedEvent**: Emitido quando um Agent conclui a execução de uma tarefa
 - **AgentExecutionErrorEvent**: Emitido quando um Agent encontra um erro durante a execução
+- **LiteAgentExecutionStartedEvent**: Emitido quando um LiteAgent inicia a execução. Contém as informações do agente, ferramentas e mensagens.
+- **LiteAgentExecutionCompletedEvent**: Emitido quando um LiteAgent conclui a execução. Contém as informações do agente e a saída.
+- **LiteAgentExecutionErrorEvent**: Emitido quando um LiteAgent encontra um erro durante a execução. Contém as informações do agente e a mensagem de erro.
+- **AgentEvaluationStartedEvent**: Emitido quando uma avaliação de agente é iniciada. Contém o ID do agente, papel do agente, ID da tarefa opcional e número da iteração.
+- **AgentEvaluationCompletedEvent**: Emitido quando uma avaliação de agente é concluída. Contém o ID do agente, papel do agente, ID da tarefa opcional, número da iteração, categoria da métrica e pontuação.
+- **AgentEvaluationFailedEvent**: Emitido quando uma avaliação de agente falha. Contém o ID do agente, papel do agente, ID da tarefa opcional, número da iteração e mensagem de erro.
 
 ### Eventos de Task
 
@@ -219,6 +226,16 @@ O CrewAI fornece uma ampla variedade de eventos para escuta:
 - **ToolExecutionErrorEvent**: Emitido quando ocorre erro na execução de uma ferramenta
 - **ToolSelectionErrorEvent**: Emitido ao ocorrer erro na seleção de uma ferramenta
 
+### Eventos de MCP
+
+- **MCPConnectionStartedEvent**: Emitido ao iniciar a conexão com um servidor MCP. Contém o nome do servidor, URL, tipo de transporte, timeout de conexão e se é uma tentativa de reconexão.
+- **MCPConnectionCompletedEvent**: Emitido ao conectar com sucesso a um servidor MCP. Contém o nome do servidor, duração da conexão em milissegundos e se foi uma reconexão.
+- **MCPConnectionFailedEvent**: Emitido quando a conexão com um servidor MCP falha. Contém o nome do servidor, mensagem de erro e tipo de erro (`timeout`, `authentication`, `network`, etc.).
+- **MCPToolExecutionStartedEvent**: Emitido ao iniciar a execução de uma ferramenta MCP. Contém o nome do servidor, nome da ferramenta e argumentos da ferramenta.
+- **MCPToolExecutionCompletedEvent**: Emitido quando a execução de uma ferramenta MCP é concluída com sucesso. Contém o nome do servidor, nome da ferramenta, resultado e duração da execução em milissegundos.
+- **MCPToolExecutionFailedEvent**: Emitido quando a execução de uma ferramenta MCP falha. Contém o nome do servidor, nome da ferramenta, mensagem de erro e tipo de erro (`timeout`, `validation`, `server_error`, etc.).
+- **MCPConfigFetchFailedEvent**: Emitido quando a obtenção da configuração de um servidor MCP falha (ex.: o MCP não está conectado na sua conta, erro de API ou falha de conexão após a configuração ser obtida). Contém o slug, mensagem de erro e tipo de erro (`not_connected`, `api_error`, `connection_failed`).
+
 ### Eventos de Knowledge
 
 - **KnowledgeRetrievalStartedEvent**: Emitido ao iniciar recuperação de conhecimento
@@ -232,16 +249,26 @@ O CrewAI fornece uma ampla variedade de eventos para escuta:
 
 - **LLMGuardrailStartedEvent**: Emitido ao iniciar validação dos guardrails. Contém detalhes do guardrail aplicado e tentativas.
 - **LLMGuardrailCompletedEvent**: Emitido ao concluir validação dos guardrails. Contém detalhes sobre sucesso/falha na validação, resultados e mensagens de erro, se houver.
+- **LLMGuardrailFailedEvent**: Emitido quando a validação do guardrail falha. Contém a mensagem de erro e o número de tentativas.
 
 ### Eventos de Flow
 
 - **FlowCreatedEvent**: Emitido ao criar um Flow
 - **FlowStartedEvent**: Emitido ao iniciar a execução de um Flow
 - **FlowFinishedEvent**: Emitido ao concluir a execução de um Flow
+- **FlowPausedEvent**: Emitido quando um Flow é pausado aguardando feedback humano. Contém o nome do flow, ID do flow, nome do método, estado atual, mensagem exibida ao solicitar feedback e lista opcional de resultados possíveis para roteamento.
 - **FlowPlotEvent**: Emitido ao plotar um Flow
 - **MethodExecutionStartedEvent**: Emitido ao iniciar a execução de um método do Flow
 - **MethodExecutionFinishedEvent**: Emitido ao concluir a execução de um método do Flow
 - **MethodExecutionFailedEvent**: Emitido ao falhar na execução de um método do Flow
+- **MethodExecutionPausedEvent**: Emitido quando um método do Flow é pausado aguardando feedback humano. Contém o nome do flow, nome do método, estado atual, ID do flow, mensagem exibida ao solicitar feedback e lista opcional de resultados possíveis para roteamento.
+
+### Eventos de Human In The Loop
+
+- **FlowInputRequestedEvent**: Emitido quando um Flow solicita entrada do usuário via `Flow.ask()`. Contém o nome do flow, nome do método, a pergunta ou prompt exibido ao usuário e metadados opcionais (ex.: ID do usuário, canal, contexto da sessão).
+- **FlowInputReceivedEvent**: Emitido quando a entrada do usuário é recebida após `Flow.ask()`. Contém o nome do flow, nome do método, a pergunta original, a resposta do usuário (ou `None` se expirou), metadados opcionais da solicitação e metadados opcionais da resposta do provedor (ex.: quem respondeu, ID do thread, timestamps).
+- **HumanFeedbackRequestedEvent**: Emitido quando um método decorado com `@human_feedback` requer entrada de um revisor humano. Contém o nome do flow, nome do método, a saída do método exibida ao humano para revisão, a mensagem exibida ao solicitar feedback e lista opcional de resultados possíveis para roteamento.
+- **HumanFeedbackReceivedEvent**: Emitido quando um humano fornece feedback em resposta a um método decorado com `@human_feedback`. Contém o nome do flow, nome do método, o texto bruto do feedback fornecido pelo humano e a string de resultado consolidada (se emit foi especificado).
 
 ### Eventos de LLM
 
@@ -249,6 +276,91 @@ O CrewAI fornece uma ampla variedade de eventos para escuta:
 - **LLMCallCompletedEvent**: Emitido ao concluir uma chamada LLM
 - **LLMCallFailedEvent**: Emitido ao falhar uma chamada LLM
 - **LLMStreamChunkEvent**: Emitido para cada chunk recebido durante respostas em streaming do LLM
+- **LLMThinkingChunkEvent**: Emitido quando um chunk de pensamento/raciocínio é recebido de um modelo de pensamento. Contém o texto do chunk e ID de resposta opcional.
+
+### Eventos de Memória
+
+- **MemoryQueryStartedEvent**: Emitido quando uma consulta de memória é iniciada. Contém a consulta, limite e threshold de pontuação opcional.
+- **MemoryQueryCompletedEvent**: Emitido quando uma consulta de memória é concluída com sucesso. Contém a consulta, resultados, limite, threshold de pontuação e tempo de execução da consulta.
+- **MemoryQueryFailedEvent**: Emitido quando uma consulta de memória falha. Contém a consulta, limite, threshold de pontuação e mensagem de erro.
+- **MemorySaveStartedEvent**: Emitido quando uma operação de salvamento de memória é iniciada. Contém o valor a ser salvo, metadados e papel do agente opcional.
+- **MemorySaveCompletedEvent**: Emitido quando uma operação de salvamento de memória é concluída com sucesso. Contém o valor salvo, metadados, papel do agente e tempo de salvamento.
+- **MemorySaveFailedEvent**: Emitido quando uma operação de salvamento de memória falha. Contém o valor, metadados, papel do agente e mensagem de erro.
+- **MemoryRetrievalStartedEvent**: Emitido quando a recuperação de memória para um prompt de tarefa é iniciada. Contém o ID da tarefa opcional.
+- **MemoryRetrievalCompletedEvent**: Emitido quando a recuperação de memória para um prompt de tarefa é concluída com sucesso. Contém o ID da tarefa, conteúdo da memória e tempo de execução da recuperação.
+- **MemoryRetrievalFailedEvent**: Emitido quando a recuperação de memória para um prompt de tarefa falha. Contém o ID da tarefa opcional e mensagem de erro.
+
+### Eventos de Raciocínio
+
+- **AgentReasoningStartedEvent**: Emitido quando um agente começa a raciocinar sobre uma tarefa. Contém o papel do agente, ID da tarefa e número da tentativa.
+- **AgentReasoningCompletedEvent**: Emitido quando um agente finaliza seu processo de raciocínio. Contém o papel do agente, ID da tarefa, o plano produzido e se o agente está pronto para prosseguir.
+- **AgentReasoningFailedEvent**: Emitido quando o processo de raciocínio falha. Contém o papel do agente, ID da tarefa e mensagem de erro.
+
+### Eventos de Observação
+
+- **StepObservationStartedEvent**: Emitido quando o Planner começa a observar o resultado de um passo. Disparado após cada execução de passo, antes da chamada LLM de observação. Contém o papel do agente, número do passo e descrição do passo.
+- **StepObservationCompletedEvent**: Emitido quando o Planner finaliza a observação do resultado de um passo. Contém se o passo foi concluído com sucesso, informações-chave aprendidas, se o plano restante ainda é válido, se é necessário um replanejamento completo e refinamentos sugeridos.
+- **StepObservationFailedEvent**: Emitido quando a chamada LLM de observação falha. O sistema continua o plano por padrão. Contém a mensagem de erro.
+- **PlanRefinementEvent**: Emitido quando o Planner refina descrições de passos futuros sem replanejamento completo. Contém o número de passos refinados e os refinamentos aplicados.
+- **PlanReplanTriggeredEvent**: Emitido quando o Planner dispara um replanejamento completo porque o plano restante foi considerado fundamentalmente incorreto. Contém o motivo do replanejamento, contagem de replanejamentos e número de passos concluídos preservados.
+- **GoalAchievedEarlyEvent**: Emitido quando o Planner detecta que o objetivo foi alcançado antecipadamente e os passos restantes serão ignorados. Contém o número de passos restantes e passos concluídos.
+
+### Eventos A2A (Agent-to-Agent)
+
+#### Eventos de Delegação
+
+- **A2ADelegationStartedEvent**: Emitido quando a delegação A2A é iniciada. Contém a URL do endpoint, descrição da tarefa, ID do agente, ID do contexto, se é multiturn, número do turno, metadados do agent card, versão do protocolo, informações do provedor e ID da skill opcional.
+- **A2ADelegationCompletedEvent**: Emitido quando a delegação A2A é concluída. Contém o status de conclusão (`completed`, `input_required`, `failed`, etc.), resultado, mensagem de erro, ID do contexto e metadados do agent card.
+- **A2AParallelDelegationStartedEvent**: Emitido quando a delegação paralela para múltiplos agentes A2A é iniciada. Contém a lista de endpoints e a descrição da tarefa.
+- **A2AParallelDelegationCompletedEvent**: Emitido quando a delegação paralela para múltiplos agentes A2A é concluída. Contém a lista de endpoints, contagem de sucessos, contagem de falhas e resumo dos resultados.
+
+#### Eventos de Conversação
+
+- **A2AConversationStartedEvent**: Emitido uma vez no início de uma conversação multiturn A2A, antes da primeira troca de mensagens. Contém o ID do agente, endpoint, ID do contexto, metadados do agent card, versão do protocolo e informações do provedor.
+- **A2AMessageSentEvent**: Emitido quando uma mensagem é enviada ao agente A2A. Contém o conteúdo da mensagem, número do turno, ID do contexto, ID da mensagem e se é multiturn.
+- **A2AResponseReceivedEvent**: Emitido quando uma resposta é recebida do agente A2A. Contém o conteúdo da resposta, número do turno, ID do contexto, ID da mensagem, status e se é a resposta final.
+- **A2AConversationCompletedEvent**: Emitido uma vez ao final de uma conversação multiturn A2A. Contém o status final (`completed` ou `failed`), resultado final, mensagem de erro, ID do contexto e número total de turnos.
+
+#### Eventos de Streaming
+
+- **A2AStreamingStartedEvent**: Emitido quando o modo streaming é iniciado para delegação A2A. Contém o ID da tarefa, ID do contexto, endpoint, número do turno e se é multiturn.
+- **A2AStreamingChunkEvent**: Emitido quando um chunk de streaming é recebido. Contém o texto do chunk, índice do chunk, se é o chunk final, ID da tarefa, ID do contexto e número do turno.
+
+#### Eventos de Polling e Push Notification
+
+- **A2APollingStartedEvent**: Emitido quando o modo polling é iniciado para delegação A2A. Contém o ID da tarefa, ID do contexto, intervalo de polling em segundos e endpoint.
+- **A2APollingStatusEvent**: Emitido em cada iteração de polling. Contém o ID da tarefa, ID do contexto, estado atual da tarefa, segundos decorridos e contagem de polls.
+- **A2APushNotificationRegisteredEvent**: Emitido quando um callback de push notification é registrado. Contém o ID da tarefa, ID do contexto, URL do callback e endpoint.
+- **A2APushNotificationReceivedEvent**: Emitido quando uma push notification é recebida do agente A2A remoto. Contém o ID da tarefa, ID do contexto e estado atual.
+- **A2APushNotificationSentEvent**: Emitido quando uma push notification é enviada para uma URL de callback. Contém o ID da tarefa, ID do contexto, URL do callback, estado, se a entrega foi bem-sucedida e mensagem de erro opcional.
+- **A2APushNotificationTimeoutEvent**: Emitido quando a espera por push notification expira. Contém o ID da tarefa, ID do contexto e duração do timeout em segundos.
+
+#### Eventos de Conexão e Autenticação
+
+- **A2AAgentCardFetchedEvent**: Emitido quando um agent card é obtido com sucesso. Contém o endpoint, nome do agente, metadados do agent card, versão do protocolo, informações do provedor, se foi do cache e tempo de busca em milissegundos.
+- **A2AAuthenticationFailedEvent**: Emitido quando a autenticação com um agente A2A falha. Contém o endpoint, tipo de autenticação tentada (ex.: `bearer`, `oauth2`, `api_key`), mensagem de erro e código de status HTTP.
+- **A2AConnectionErrorEvent**: Emitido quando ocorre um erro de conexão durante a comunicação A2A. Contém o endpoint, mensagem de erro, tipo de erro (ex.: `timeout`, `connection_refused`, `dns_error`), código de status HTTP e a operação sendo tentada.
+- **A2ATransportNegotiatedEvent**: Emitido quando o protocolo de transporte é negociado com um agente A2A. Contém o transporte negociado, URL negociada, fonte de seleção (`client_preferred`, `server_preferred`, `fallback`) e transportes suportados pelo cliente/servidor.
+- **A2AContentTypeNegotiatedEvent**: Emitido quando os tipos de conteúdo são negociados com um agente A2A. Contém os modos de entrada/saída do cliente/servidor, modos de entrada/saída negociados e se a negociação foi bem-sucedida.
+
+#### Eventos de Artefatos
+
+- **A2AArtifactReceivedEvent**: Emitido quando um artefato é recebido de um agente A2A remoto. Contém o ID da tarefa, ID do artefato, nome do artefato, descrição, tipo MIME, tamanho em bytes e se o conteúdo deve ser concatenado.
+
+#### Eventos de Tarefa do Servidor
+
+- **A2AServerTaskStartedEvent**: Emitido quando a execução de uma tarefa do servidor A2A é iniciada. Contém o ID da tarefa e ID do contexto.
+- **A2AServerTaskCompletedEvent**: Emitido quando a execução de uma tarefa do servidor A2A é concluída. Contém o ID da tarefa, ID do contexto e resultado.
+- **A2AServerTaskCanceledEvent**: Emitido quando a execução de uma tarefa do servidor A2A é cancelada. Contém o ID da tarefa e ID do contexto.
+- **A2AServerTaskFailedEvent**: Emitido quando a execução de uma tarefa do servidor A2A falha. Contém o ID da tarefa, ID do contexto e mensagem de erro.
+
+#### Eventos de Ciclo de Vida do Contexto
+
+- **A2AContextCreatedEvent**: Emitido quando um contexto A2A é criado. Contextos agrupam tarefas relacionadas em uma conversação ou workflow. Contém o ID do contexto e timestamp de criação.
+- **A2AContextExpiredEvent**: Emitido quando um contexto A2A expira devido ao TTL. Contém o ID do contexto, timestamp de criação, idade em segundos e contagem de tarefas.
+- **A2AContextIdleEvent**: Emitido quando um contexto A2A fica inativo (sem atividade pelo threshold configurado). Contém o ID do contexto, tempo de inatividade em segundos e contagem de tarefas.
+- **A2AContextCompletedEvent**: Emitido quando todas as tarefas em um contexto A2A são concluídas. Contém o ID do contexto, total de tarefas e duração em segundos.
+- **A2AContextPrunedEvent**: Emitido quando um contexto A2A é podado (deletado). Contém o ID do contexto, contagem de tarefas e idade em segundos.
 
 ## Estrutura dos Handlers de Evento
 

docs/pt-BR/concepts/skills.mdx

@@ -0,0 +1,114 @@
+---
+title: Skills
+description: Pacotes de skills baseados em sistema de arquivos que injetam contexto nos prompts dos agentes.
+icon: bolt
+mode: "wide"
+---
+
+## Visão Geral
+
+Skills são diretórios autocontidos que fornecem aos agentes instruções, referências e assets específicos de domínio. Cada skill é definida por um arquivo `SKILL.md` com frontmatter YAML e um corpo em markdown.
+
+Skills usam **divulgação progressiva** — metadados são carregados primeiro, instruções completas apenas quando ativadas, e catálogos de recursos apenas quando necessário.
+
+## Estrutura de Diretório
+
+```
+my-skill/
+├── SKILL.md            # Obrigatório — frontmatter + instruções
+├── scripts/            # Opcional — scripts executáveis
+├── references/         # Opcional — documentos de referência
+└── assets/             # Opcional — arquivos estáticos (configs, dados)
+```
+
+O nome do diretório deve corresponder ao campo `name` no `SKILL.md`.
+
+## Formato do SKILL.md
+
+```markdown
+---
+name: my-skill
+description: Descrição curta do que esta skill faz e quando usá-la.
+license: Apache-2.0                    # opcional
+compatibility: crewai>=0.1.0          # opcional
+metadata:                              # opcional
+  author: your-name
+  version: "1.0"
+allowed-tools: web-search file-read   # opcional, delimitado por espaços
+---
+
+Instruções para o agente vão aqui. Este corpo em markdown é injetado
+no prompt do agente quando a skill é ativada.
+```
+
+### Campos do Frontmatter
+
+| Campo           | Obrigatório | Restrições                                                               |
+| :-------------- | :---------- | :----------------------------------------------------------------------- |
+| `name`          | Sim         | 1–64 chars. Alfanumérico minúsculo e hifens. Sem hifens iniciais/finais/consecutivos. Deve corresponder ao nome do diretório. |
+| `description`   | Sim         | 1–1024 chars. Descreve o que a skill faz e quando usá-la.                |
+| `license`       | Não         | Nome da licença ou referência a um arquivo de licença incluído.           |
+| `compatibility` | Não         | Máx 500 chars. Requisitos de ambiente (produtos, pacotes, rede).          |
+| `metadata`      | Não         | Mapeamento arbitrário de chave-valor string.                              |
+| `allowed-tools` | Não         | Lista de ferramentas pré-aprovadas delimitada por espaços. Experimental.  |
+
+## Uso
+
+### Skills no Nível do Agente
+
+Passe caminhos de diretório de skills para um agente:
+
+```python
+from crewai import Agent
+
+agent = Agent(
+    role="Researcher",
+    goal="Find relevant information",
+    backstory="An expert researcher.",
+    skills=["./skills"],  # descobre todas as skills neste diretório
+)
+```
+
+### Skills no Nível do Crew
+
+Caminhos de skills no crew são mesclados em todos os agentes:
+
+```python
+from crewai import Crew
+
+crew = Crew(
+    agents=[agent],
+    tasks=[task],
+    skills=["./skills"],
+)
+```
+
+### Skills Pré-carregadas
+
+Você também pode passar objetos `Skill` diretamente:
+
+```python
+from pathlib import Path
+from crewai.skills import discover_skills, activate_skill
+
+skills = discover_skills(Path("./skills"))
+activated = [activate_skill(s) for s in skills]
+
+agent = Agent(
+    role="Researcher",
+    goal="Find relevant information",
+    backstory="An expert researcher.",
+    skills=activated,
+)
+```
+
+## Como as Skills São Carregadas
+
+Skills carregam progressivamente — apenas os dados necessários em cada etapa são lidos:
+
+| Etapa            | O que é carregado                                  | Quando              |
+| :--------------- | :------------------------------------------------ | :------------------ |
+| Descoberta       | Nome, descrição, campos do frontmatter             | `discover_skills()` |
+| Ativação         | Texto completo do corpo do SKILL.md                | `activate_skill()` |
+
+Durante a execução normal do agente, skills são automaticamente descobertas e ativadas. Os diretórios `scripts/`, `references/` e `assets/` estão disponíveis no `path` da skill para agentes que precisam referenciar arquivos diretamente.

docs/pt-BR/guides/coding-tools/agents-md.mdx

@@ -0,0 +1,61 @@
+---
+title: Ferramentas de Codificação
+description: Use o AGENTS.md para guiar agentes de codificação e IDEs em seus projetos CrewAI.
+icon: terminal
+mode: "wide"
+---
+
+## Por que AGENTS.md
+
+`AGENTS.md` é um arquivo de instruções leve e local do repositório que fornece aos agentes de codificação orientações consistentes e específicas do projeto. Mantenha-o na raiz do projeto e trate-o como a fonte da verdade para como você deseja que os assistentes trabalhem: convenções, comandos, notas de arquitetura e proteções.
+
+## Criar um Projeto com o CLI
+
+Use o CLI do CrewAI para criar a estrutura de um projeto, e o `AGENTS.md` será automaticamente adicionado na raiz.
+
+```bash
+# Crew
+crewai create crew my_crew
+
+# Flow
+crewai create flow my_flow
+
+# Tool repository
+crewai tool create my_tool
+```
+
+## Configuração de Ferramentas: Direcione Assistentes para o AGENTS.md
+
+### Codex
+
+O Codex pode ser guiado por arquivos `AGENTS.md` colocados no seu repositório. Use-os para fornecer contexto persistente do projeto, como convenções, comandos e expectativas de fluxo de trabalho.
+
+### Claude Code
+
+O Claude Code armazena a memória do projeto em `CLAUDE.md`. Você pode inicializá-lo com `/init` e editá-lo usando `/memory`. O Claude Code também suporta importações dentro do `CLAUDE.md`, então você pode adicionar uma única linha como `@AGENTS.md` para incluir as instruções compartilhadas sem duplicá-las.
+
+Você pode simplesmente usar:
+
+```bash
+mv AGENTS.md CLAUDE.md
+```
+
+### Gemini CLI e Google Antigravity
+
+O Gemini CLI e o Antigravity carregam um arquivo de contexto do projeto (padrão: `GEMINI.md`) da raiz do repositório e diretórios pais. Você pode configurá-lo para ler o `AGENTS.md` em vez disso (ou além) definindo `context.fileName` nas configurações do Gemini CLI. Por exemplo, defina apenas para `AGENTS.md`, ou inclua tanto `AGENTS.md` quanto `GEMINI.md` se quiser manter o formato de cada ferramenta.
+
+Você pode simplesmente usar:
+
+```bash
+mv AGENTS.md GEMINI.md
+```
+
+### Cursor
+
+O Cursor suporta `AGENTS.md` como arquivo de instruções do projeto. Coloque-o na raiz do projeto para fornecer orientação ao assistente de codificação do Cursor.
+
+### Windsurf
+
+O Claude Code fornece uma integração oficial com o Windsurf. Se você usa o Claude Code dentro do Windsurf, siga a orientação do Claude Code acima e importe o `AGENTS.md` a partir do `CLAUDE.md`.
+
+Se você está usando o assistente nativo do Windsurf, configure o recurso de regras ou instruções do projeto (se disponível) para ler o `AGENTS.md` ou cole o conteúdo diretamente.

docs/pt-BR/guides/tools/publish-custom-tools.mdx

@@ -0,0 +1,244 @@
+---
+title: Publicar Ferramentas Personalizadas
+description: Como construir, empacotar e publicar suas próprias ferramentas compatíveis com CrewAI no PyPI para que qualquer usuário do CrewAI possa instalá-las e usá-las.
+icon: box-open
+mode: "wide"
+---
+
+## Visão Geral
+
+O sistema de ferramentas do CrewAI foi projetado para ser extensível. Se você construiu uma ferramenta que pode beneficiar outros, pode empacotá-la como uma biblioteca Python independente, publicá-la no PyPI e disponibilizá-la para qualquer usuário do CrewAI — sem necessidade de PR para o repositório do CrewAI.
+
+Este guia percorre todo o processo: implementação do contrato de ferramentas, estruturação do pacote e publicação no PyPI.
+
+<Note type="info" title="Não pretende publicar?">
+Se você precisa apenas de uma ferramenta personalizada para seu próprio projeto, consulte o guia [Criar Ferramentas Personalizadas](/pt-BR/learn/create-custom-tools).
+</Note>
+
+## O Contrato de Ferramentas
+
+Toda ferramenta CrewAI deve satisfazer uma das duas interfaces:
+
+### Opção 1: Subclassificar `BaseTool`
+
+Subclassifique `crewai.tools.BaseTool` e implemente o método `_run`. Defina `name`, `description` e, opcionalmente, um `args_schema` para validação de entrada.
+
+```python
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+
+class GeolocateInput(BaseModel):
+    """Esquema de entrada para GeolocateTool."""
+    address: str = Field(..., description="O endereço para geolocalizar.")
+
+
+class GeolocateTool(BaseTool):
+    name: str = "Geolocate"
+    description: str = "Converte um endereço em coordenadas de latitude/longitude."
+    args_schema: type[BaseModel] = GeolocateInput
+
+    def _run(self, address: str) -> str:
+        # Sua implementação aqui
+        return f"40.7128, -74.0060"
+```
+
+### Opção 2: Usar o Decorador `@tool`
+
+Para ferramentas mais simples, o decorador `@tool` transforma uma função em uma ferramenta CrewAI. A função **deve** ter uma docstring (usada como descrição da ferramenta) e anotações de tipo.
+
+```python
+from crewai.tools import tool
+
+
+@tool("Geolocate")
+def geolocate(address: str) -> str:
+    """Converte um endereço em coordenadas de latitude/longitude."""
+    return "40.7128, -74.0060"
+```
+
+### Requisitos Essenciais
+
+Independentemente da abordagem escolhida, sua ferramenta deve:
+
+- Ter um **`name`** — um identificador curto e descritivo.
+- Ter uma **`description`** — informa ao agente quando e como usar a ferramenta. Isso afeta diretamente a qualidade do uso da ferramenta pelo agente, então seja claro e específico.
+- Implementar **`_run`** (BaseTool) ou fornecer um **corpo de função** (@tool) — a lógica de execução síncrona.
+- Usar **anotações de tipo** em todos os parâmetros e valores de retorno.
+- Retornar um resultado em **string** (ou algo que possa ser convertido de forma significativa).
+
+### Opcional: Suporte Assíncrono
+
+Se sua ferramenta realiza operações de I/O, implemente `_arun` para execução assíncrona:
+
+```python
+class GeolocateTool(BaseTool):
+    name: str = "Geolocate"
+    description: str = "Converte um endereço em coordenadas de latitude/longitude."
+
+    def _run(self, address: str) -> str:
+        # Implementação síncrona
+        ...
+
+    async def _arun(self, address: str) -> str:
+        # Implementação assíncrona
+        ...
+```
+
+### Opcional: Validação de Entrada com `args_schema`
+
+Defina um modelo Pydantic como seu `args_schema` para obter validação automática de entrada e mensagens de erro claras. Se não fornecer um, o CrewAI irá inferi-lo da assinatura do seu método `_run`.
+
+```python
+from pydantic import BaseModel, Field
+
+
+class TranslateInput(BaseModel):
+    """Esquema de entrada para TranslateTool."""
+    text: str = Field(..., description="O texto a ser traduzido.")
+    target_language: str = Field(
+        default="en",
+        description="Código de idioma ISO 639-1 para o idioma de destino.",
+    )
+```
+
+Esquemas explícitos são recomendados para ferramentas publicadas — produzem melhor comportamento do agente e documentação mais clara para seus usuários.
+
+### Opcional: Variáveis de Ambiente
+
+Se sua ferramenta requer chaves de API ou outra configuração, declare-as com `env_vars` para que os usuários saibam o que configurar:
+
+```python
+from crewai.tools import BaseTool, EnvVar
+
+
+class GeolocateTool(BaseTool):
+    name: str = "Geolocate"
+    description: str = "Converte um endereço em coordenadas de latitude/longitude."
+    env_vars: list[EnvVar] = [
+        EnvVar(
+            name="GEOCODING_API_KEY",
+            description="Chave de API para o serviço de geocodificação.",
+            required=True,
+        ),
+    ]
+
+    def _run(self, address: str) -> str:
+        ...
+```
+
+## Estrutura do Pacote
+
+Estruture seu projeto como um pacote Python padrão. Layout recomendado:
+
+```
+crewai-geolocate/
+├── pyproject.toml
+├── LICENSE
+├── README.md
+└── src/
+    └── crewai_geolocate/
+        ├── __init__.py
+        └── tools.py
+```
+
+### `pyproject.toml`
+
+```toml
+[project]
+name = "crewai-geolocate"
+version = "0.1.0"
+description = "Uma ferramenta CrewAI para geolocalizar endereços."
+requires-python = ">=3.10"
+dependencies = [
+    "crewai",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+```
+
+Declare `crewai` como dependência para que os usuários obtenham automaticamente uma versão compatível.
+
+### `__init__.py`
+
+Re-exporte suas classes de ferramenta para que os usuários possam importá-las diretamente:
+
+```python
+from crewai_geolocate.tools import GeolocateTool
+
+__all__ = ["GeolocateTool"]
+```
+
+### Convenções de Nomenclatura
+
+- **Nome do pacote**: Use o prefixo `crewai-` (ex.: `crewai-geolocate`). Isso torna sua ferramenta fácil de encontrar no PyPI.
+- **Nome do módulo**: Use underscores (ex.: `crewai_geolocate`).
+- **Nome da classe da ferramenta**: Use PascalCase terminando em `Tool` (ex.: `GeolocateTool`).
+
+## Testando sua Ferramenta
+
+Antes de publicar, verifique se sua ferramenta funciona dentro de uma crew:
+
+```python
+from crewai import Agent, Crew, Task
+from crewai_geolocate import GeolocateTool
+
+agent = Agent(
+    role="Analista de Localização",
+    goal="Encontrar coordenadas para os endereços fornecidos.",
+    backstory="Um especialista em dados geoespaciais.",
+    tools=[GeolocateTool()],
+)
+
+task = Task(
+    description="Encontre as coordenadas de 1600 Pennsylvania Avenue, Washington, DC.",
+    expected_output="A latitude e longitude do endereço.",
+    agent=agent,
+)
+
+crew = Crew(agents=[agent], tasks=[task])
+result = crew.kickoff()
+print(result)
+```
+
+## Publicando no PyPI
+
+Quando sua ferramenta estiver testada e pronta:
+
+```bash
+# Construir o pacote
+uv build
+
+# Publicar no PyPI
+uv publish
+```
+
+Se é sua primeira vez publicando, você precisará de uma [conta no PyPI](https://pypi.org/account/register/) e um [token de API](https://pypi.org/help/#apitoken).
+
+### Após a Publicação
+
+Os usuários podem instalar sua ferramenta com:
+
+```bash
+pip install crewai-geolocate
+```
+
+Ou com uv:
+
+```bash
+uv add crewai-geolocate
+```
+
+E então usá-la em suas crews:
+
+```python
+from crewai_geolocate import GeolocateTool
+
+agent = Agent(
+    role="Analista de Localização",
+    tools=[GeolocateTool()],
+    # ...
+)
+```

docs/pt-BR/learn/create-custom-tools.mdx

@@ -11,6 +11,10 @@ Este guia traz instruções detalhadas sobre como criar ferramentas personalizad
 incorporando funcionalidades recentes, como delegação de ferramentas, tratamento de erros e chamada dinâmica de ferramentas. Destaca também a importância de ferramentas de colaboração,
 permitindo que agentes executem uma ampla gama de ações.
 
+<Tip>
+  **Quer publicar sua ferramenta para a comunidade?** Se você está construindo uma ferramenta que pode beneficiar outros, confira o guia [Publicar Ferramentas Personalizadas](/pt-BR/guides/tools/publish-custom-tools) para aprender como empacotar e distribuir sua ferramenta no PyPI.
+</Tip>
+
 ### Subclassificando `BaseTool`
 
 Para criar uma ferramenta personalizada, herde de `BaseTool` e defina os atributos necessários, incluindo o `args_schema` para validação de entrada e o método `_run`.

lib/crewai-files/pyproject.toml

@@ -9,11 +9,11 @@ authors = [
 requires-python = ">=3.10, <3.14"
 dependencies = [
     "Pillow~=12.1.1",
-    "pypdf~=6.7.5",
+    "pypdf~=6.9.1",
     "python-magic>=0.4.27",
     "aiocache~=0.12.3",
     "aiofiles~=24.1.0",
-    "tinytag~=1.10.0",
+    "tinytag~=2.2.1",
     "av~=13.0.0",
 ]
 

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

@@ -152,4 +152,4 @@ __all__ = [
     "wrap_file_source",
 ]
 
-__version__ = "1.11.0rc2"
+__version__ = "1.11.1"

lib/crewai-tools/pyproject.toml

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

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

@@ -309,4 +309,4 @@ __all__ = [
     "ZapierActionTools",
 ]
 
-__version__ = "1.11.0rc2"
+__version__ = "1.11.1"

lib/crewai-tools/src/crewai_tools/rag/loaders/pdf_loader.py

@@ -1,10 +1,12 @@
 """PDF loader for extracting text from PDF files."""
 
 import os
+import tempfile
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 from urllib.parse import urlparse
-import urllib.request
+
+import requests
 
 from crewai_tools.rag.base_loader import BaseLoader, LoaderResult
 from crewai_tools.rag.source_content import SourceContent
@@ -23,22 +25,34 @@ class PDFLoader(BaseLoader):
             return False
 
     @staticmethod
-    def _download_pdf(url: str) -> bytes:
-        """Download PDF content from a URL.
+    def _download_from_url(url: str, kwargs: dict) -> str:
+        """Download PDF from a URL to a temporary file and return its path.
 
         Args:
             url: The URL to download from.
+            kwargs: Optional dict that may contain custom headers.
 
         Returns:
-            The PDF content as bytes.
+            Path to the temporary file containing the PDF.
 
         Raises:
             ValueError: If the download fails.
         """
+        headers = kwargs.get(
+            "headers",
+            {
+                "Accept": "application/pdf",
+                "User-Agent": "Mozilla/5.0 (compatible; crewai-tools PDFLoader)",
+            },
+        )
 
         try:
-            with urllib.request.urlopen(url, timeout=30) as response:  # noqa: S310
-                return cast(bytes, response.read())
+            response = requests.get(url, headers=headers, timeout=30)
+            response.raise_for_status()
+
+            with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as temp_file:
+                temp_file.write(response.content)
+                return temp_file.name
         except Exception as e:
             raise ValueError(f"Failed to download PDF from {url}: {e!s}") from e
 
@@ -80,8 +94,8 @@ class PDFLoader(BaseLoader):
 
         try:
             if is_url:
-                pdf_bytes = self._download_pdf(file_path)
-                doc = pymupdf.open(stream=pdf_bytes, filetype="pdf")
+                local_path = self._download_from_url(file_path, kwargs)
+                doc = pymupdf.open(local_path)
             else:
                 if not os.path.isfile(file_path):
                     raise FileNotFoundError(f"PDF file not found: {file_path}")

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

@@ -1,4 +1,5 @@
 import os
+from pathlib import Path
 from typing import Any
 
 from crewai.tools import BaseTool
@@ -30,27 +31,39 @@ class FileWriterTool(BaseTool):
 
     def _run(self, **kwargs: Any) -> str:
         try:
+            directory = kwargs.get("directory") or "./"
+            filename = kwargs["filename"]
+
+            filepath = os.path.join(directory, filename)
+
+            # Prevent path traversal: the resolved path must be strictly inside
+            # the resolved directory. This blocks ../sequences, absolute paths in
+            # filename, and symlink escapes regardless of how directory is set.
+            # is_relative_to() does a proper path-component comparison that is
+            # safe on case-insensitive filesystems and avoids the "// " edge case
+            # that plagues startswith(real_directory + os.sep).
+            # We also reject the case where filepath resolves to the directory
+            # itself, since that is not a valid file target.
+            real_directory = Path(directory).resolve()
+            real_filepath = Path(filepath).resolve()
+            if not real_filepath.is_relative_to(real_directory) or real_filepath == real_directory:
+                return "Error: Invalid file path — the filename must not escape the target directory."
+
             if kwargs.get("directory"):
-                os.makedirs(kwargs["directory"], exist_ok=True)
+                os.makedirs(real_directory, exist_ok=True)
 
-            # Construct the full path
-            filepath = os.path.join(kwargs.get("directory") or "", kwargs["filename"])
-
-            # Convert overwrite to boolean
             kwargs["overwrite"] = strtobool(kwargs["overwrite"])
 
-            # Check if file exists and overwrite is not allowed
-            if os.path.exists(filepath) and not kwargs["overwrite"]:
-                return f"File {filepath} already exists and overwrite option was not passed."
+            if os.path.exists(real_filepath) and not kwargs["overwrite"]:
+                return f"File {real_filepath} already exists and overwrite option was not passed."
 
-            # Write content to the file
             mode = "w" if kwargs["overwrite"] else "x"
-            with open(filepath, mode) as file:
+            with open(real_filepath, mode) as file:
                 file.write(kwargs["content"])
-            return f"Content successfully written to {filepath}"
+            return f"Content successfully written to {real_filepath}"
         except FileExistsError:
             return (
-                f"File {filepath} already exists and overwrite option was not passed."
+                f"File {real_filepath} already exists and overwrite option was not passed."
             )
         except KeyError as e:
             return f"An error occurred while accessing key: {e!s}"

lib/crewai-tools/tests/tools/test_file_writer_tool.py

@@ -135,3 +135,59 @@ def test_file_exists_error_handling(tool, temp_env, overwrite):
 
     assert "already exists and overwrite option was not passed" in result
     assert read_file(path) == "Pre-existing content"
+
+
+# --- Path traversal prevention ---
+
+def test_blocks_traversal_in_filename(tool, temp_env):
+    # Create a sibling "outside" directory so we can assert nothing was written there.
+    outside_dir = tempfile.mkdtemp()
+    outside_file = os.path.join(outside_dir, "outside.txt")
+    try:
+        result = tool._run(
+            filename=f"../{os.path.basename(outside_dir)}/outside.txt",
+            directory=temp_env["temp_dir"],
+            content="should not be written",
+            overwrite=True,
+        )
+        assert "Error" in result
+        assert not os.path.exists(outside_file)
+    finally:
+        shutil.rmtree(outside_dir, ignore_errors=True)
+
+
+def test_blocks_absolute_path_in_filename(tool, temp_env):
+    # Use a temp file outside temp_dir as the absolute target so we don't
+    # depend on /etc/passwd existing or being writable on the host.
+    outside_dir = tempfile.mkdtemp()
+    outside_file = os.path.join(outside_dir, "target.txt")
+    try:
+        result = tool._run(
+            filename=outside_file,
+            directory=temp_env["temp_dir"],
+            content="should not be written",
+            overwrite=True,
+        )
+        assert "Error" in result
+        assert not os.path.exists(outside_file)
+    finally:
+        shutil.rmtree(outside_dir, ignore_errors=True)
+
+
+def test_blocks_symlink_escape(tool, temp_env):
+    # Symlink inside temp_dir pointing to a separate temp "outside" directory.
+    outside_dir = tempfile.mkdtemp()
+    outside_file = os.path.join(outside_dir, "target.txt")
+    link = os.path.join(temp_env["temp_dir"], "escape")
+    os.symlink(outside_dir, link)
+    try:
+        result = tool._run(
+            filename="escape/target.txt",
+            directory=temp_env["temp_dir"],
+            content="should not be written",
+            overwrite=True,
+        )
+        assert "Error" in result
+        assert not os.path.exists(outside_file)
+    finally:
+        shutil.rmtree(outside_dir, ignore_errors=True)

lib/crewai/pyproject.toml

@@ -42,6 +42,7 @@ dependencies = [
     "mcp~=1.26.0",
     "uv~=0.9.13",
     "aiosqlite~=0.21.0",
+    "pyyaml~=6.0",
     "lancedb>=0.29.2",
 ]
 
@@ -53,7 +54,7 @@ Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
 tools = [
-    "crewai-tools==1.11.0rc2",
+    "crewai-tools==1.11.1",
 ]
 embeddings = [
     "tiktoken~=0.8.0"
@@ -82,7 +83,7 @@ voyageai = [
     "voyageai~=0.3.5",
 ]
 litellm = [
-    "litellm>=1.74.9,<3",
+    "litellm>=1.74.9,<=1.82.6",
 ]
 bedrock = [
     "boto3~=1.40.45",

lib/crewai/src/crewai/__init__.py

@@ -42,7 +42,7 @@ def _suppress_pydantic_deprecation_warnings() -> None:
 
 _suppress_pydantic_deprecation_warnings()
 
-__version__ = "1.11.0rc2"
+__version__ = "1.11.1"
 _telemetry_submitted = False
 
 

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

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 from collections.abc import Callable, Coroutine, Sequence
 import contextvars
+from pathlib import Path
 import shutil
 import subprocess
 import time
@@ -26,6 +27,7 @@ from typing_extensions import Self
 from crewai.agent.planning_config import PlanningConfig
 from crewai.agent.utils import (
     ahandle_knowledge_retrieval,
+    append_skill_context,
     apply_training_data,
     build_task_prompt_with_schema,
     format_task_with_context,
@@ -65,7 +67,10 @@ from crewai.mcp import MCPServerConfig
 from crewai.mcp.tool_resolver import MCPToolResolver
 from crewai.rag.embeddings.types import EmbedderConfig
 from crewai.security.fingerprint import Fingerprint
+from crewai.skills.loader import activate_skill, discover_skills
+from crewai.skills.models import INSTRUCTIONS, Skill as SkillModel
 from crewai.tools.agent_tools.agent_tools import AgentTools
+from crewai.types.callback import SerializableCallable
 from crewai.utilities.agent_utils import (
     get_tool_names,
     is_inside_event_loop,
@@ -75,6 +80,7 @@ from crewai.utilities.agent_utils import (
 )
 from crewai.utilities.constants import TRAINED_AGENTS_DATA_FILE, TRAINING_DATA_FILE
 from crewai.utilities.converter import Converter, ConverterError
+from crewai.utilities.env import get_env_context
 from crewai.utilities.guardrail import process_guardrail
 from crewai.utilities.guardrail_types import GuardrailType
 from crewai.utilities.llm_utils import create_llm
@@ -142,7 +148,7 @@ class Agent(BaseAgent):
         default=None,
         description="Maximum execution time for an agent to execute a task",
     )
-    step_callback: Any | None = Field(
+    step_callback: SerializableCallable | None = Field(
         default=None,
         description="Callback to be executed after each step of the agent execution.",
     )
@@ -150,10 +156,10 @@ class Agent(BaseAgent):
         default=True,
         description="Use system prompt for the agent.",
     )
-    llm: str | InstanceOf[BaseLLM] | Any = Field(
+    llm: str | InstanceOf[BaseLLM] | None = Field(
         description="Language model that will run the agent.", default=None
     )
-    function_calling_llm: str | InstanceOf[BaseLLM] | Any | None = Field(
+    function_calling_llm: str | InstanceOf[BaseLLM] | None = Field(
         description="Language model that will run the agent.", default=None
     )
     system_template: str | None = Field(
@@ -276,6 +282,8 @@ class Agent(BaseAgent):
         if self.allow_code_execution:
             self._validate_docker_installation()
 
+        self.set_skills()
+
         # Handle backward compatibility: convert reasoning=True to planning_config
         if self.reasoning and self.planning_config is None:
             import warnings
@@ -319,6 +327,76 @@ class Agent(BaseAgent):
         except (TypeError, ValueError) as e:
             raise ValueError(f"Invalid Knowledge Configuration: {e!s}") from e
 
+    def set_skills(
+        self,
+        resolved_crew_skills: list[SkillModel] | None = None,
+    ) -> None:
+        """Resolve skill paths and activate skills to INSTRUCTIONS level.
+
+        Path entries trigger discovery and activation. Pre-loaded Skill objects
+        below INSTRUCTIONS level are activated. Crew-level skills are merged in
+        with event emission so observability is consistent regardless of origin.
+
+        Args:
+            resolved_crew_skills: Pre-resolved crew skills (already discovered
+                and activated). When provided, avoids redundant discovery per agent.
+        """
+        from crewai.crew import Crew
+        from crewai.events.event_bus import crewai_event_bus
+        from crewai.events.types.skill_events import SkillActivatedEvent
+
+        if resolved_crew_skills is None:
+            crew_skills: list[Path | SkillModel] | None = (
+                self.crew.skills
+                if isinstance(self.crew, Crew) and isinstance(self.crew.skills, list)
+                else None
+            )
+        else:
+            crew_skills = list(resolved_crew_skills)
+
+        if not self.skills and not crew_skills:
+            return
+
+        needs_work = self.skills and any(
+            isinstance(s, Path)
+            or (isinstance(s, SkillModel) and s.disclosure_level < INSTRUCTIONS)
+            for s in self.skills
+        )
+        if not needs_work and not crew_skills:
+            return
+
+        seen: set[str] = set()
+        resolved: list[Path | SkillModel] = []
+        items: list[Path | SkillModel] = list(self.skills) if self.skills else []
+
+        if crew_skills:
+            items.extend(crew_skills)
+
+        for item in items:
+            if isinstance(item, Path):
+                discovered = discover_skills(item, source=self)
+                for skill in discovered:
+                    if skill.name not in seen:
+                        seen.add(skill.name)
+                        resolved.append(activate_skill(skill, source=self))
+            elif isinstance(item, SkillModel):
+                if item.name not in seen:
+                    seen.add(item.name)
+                    activated = activate_skill(item, source=self)
+                    if activated is item and item.disclosure_level >= INSTRUCTIONS:
+                        crewai_event_bus.emit(
+                            self,
+                            event=SkillActivatedEvent(
+                                from_agent=self,
+                                skill_name=item.name,
+                                skill_path=item.path,
+                                disclosure_level=item.disclosure_level,
+                            ),
+                        )
+                    resolved.append(activated)
+
+        self.skills = resolved if resolved else None
+
     def _is_any_available_memory(self) -> bool:
         """Check if unified memory is available (agent or crew)."""
         if getattr(self, "memory", None):
@@ -339,7 +417,7 @@ class Agent(BaseAgent):
         return (
             hasattr(self.llm, "supports_function_calling")
             and callable(getattr(self.llm, "supports_function_calling", None))
-            and self.llm.supports_function_calling()
+            and self.llm.supports_function_calling()  # type: ignore[union-attr]
             and len(tools) > 0
         )
 
@@ -364,6 +442,7 @@ class Agent(BaseAgent):
             ValueError: If the max execution time is not a positive integer.
             RuntimeError: If the agent execution fails for other reasons.
         """
+        get_env_context()
         # Only call handle_reasoning for legacy CrewAgentExecutor
         # For AgentExecutor, planning is handled in AgentExecutor.generate_plan()
         if self.executor_class is not AgentExecutor:
@@ -439,6 +518,8 @@ class Agent(BaseAgent):
             self.crew.query_knowledge if self.crew else lambda *a, **k: None,
         )
 
+        task_prompt = append_skill_context(self, task_prompt)
+
         prepare_tools(self, tools, task)
         task_prompt = apply_training_data(self, task_prompt)
 
@@ -679,6 +760,8 @@ class Agent(BaseAgent):
             self, task, task_prompt, knowledge_config
         )
 
+        task_prompt = append_skill_context(self, task_prompt)
+
         prepare_tools(self, tools, task)
         task_prompt = apply_training_data(self, task_prompt)
 
@@ -1340,6 +1423,8 @@ class Agent(BaseAgent):
                     ),
                 )
 
+        formatted_messages = append_skill_context(self, formatted_messages)
+
         # Build the input dict for the executor
         inputs: dict[str, Any] = {
             "input": formatted_messages,

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

@@ -210,6 +210,30 @@ def _combine_knowledge_context(agent: Agent) -> str:
     return agent_ctx + separator + crew_ctx
 
 
+def append_skill_context(agent: Agent, task_prompt: str) -> str:
+    """Append activated skill context sections to the task prompt.
+
+    Args:
+        agent: The agent with optional skills.
+        task_prompt: The current task prompt.
+
+    Returns:
+        The task prompt with skill context appended.
+    """
+    if not agent.skills:
+        return task_prompt
+
+    from crewai.skills.loader import format_skill_context
+    from crewai.skills.models import Skill
+
+    skill_sections = [
+        format_skill_context(s) for s in agent.skills if isinstance(s, Skill)
+    ]
+    if skill_sections:
+        task_prompt += "\n\n" + "\n\n".join(skill_sections)
+    return task_prompt
+
+
 def apply_training_data(agent: Agent, task_prompt: str) -> str:
     """Apply training data to the task prompt.
 

lib/crewai/src/crewai/agents/agent_adapters/base_converter_adapter.py

@@ -5,9 +5,12 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import json
 import re
-from typing import TYPE_CHECKING, Any, Final, Literal
+from typing import TYPE_CHECKING, Final, Literal
 
-from crewai.utilities.pydantic_schema_utils import generate_model_description
+from crewai.utilities.pydantic_schema_utils import (
+    ModelDescription,
+    generate_model_description,
+)
 
 
 if TYPE_CHECKING:
@@ -41,7 +44,7 @@ class BaseConverterAdapter(ABC):
         """
         self.agent_adapter = agent_adapter
         self._output_format: Literal["json", "pydantic"] | None = None
-        self._schema: dict[str, Any] | None = None
+        self._schema: ModelDescription | None = None
 
     @abstractmethod
     def configure_structured_output(self, task: Task) -> None:
@@ -128,7 +131,7 @@ class BaseConverterAdapter(ABC):
     @staticmethod
     def _configure_format_from_task(
         task: Task,
-    ) -> tuple[Literal["json", "pydantic"] | None, dict[str, Any] | None]:
+    ) -> tuple[Literal["json", "pydantic"] | None, ModelDescription | None]:
         """Determine output format and schema from task requirements.
 
         This is a helper method that examines the task's output requirements

lib/crewai/src/crewai/agents/agent_adapters/langgraph/langgraph_adapter.py

@@ -64,7 +64,7 @@ class LangGraphAgentAdapter(BaseAgentAdapter):
         llm: Any = None,
         max_iterations: int = 10,
         agent_config: dict[str, Any] | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         """Initialize the LangGraph agent adapter.
 

lib/crewai/src/crewai/agents/agent_builder/base_agent.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import Callable
 from copy import copy as shallow_copy
 from hashlib import md5
+from pathlib import Path
 import re
 from typing import Any, Final, Literal
 import uuid
@@ -12,6 +12,7 @@ from pydantic import (
     UUID4,
     BaseModel,
     Field,
+    InstanceOf,
     PrivateAttr,
     field_validator,
     model_validator,
@@ -26,10 +27,15 @@ from crewai.agents.tools_handler import ToolsHandler
 from crewai.knowledge.knowledge import Knowledge
 from crewai.knowledge.knowledge_config import KnowledgeConfig
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
+from crewai.knowledge.storage.base_knowledge_storage import BaseKnowledgeStorage
 from crewai.mcp.config import MCPServerConfig
+from crewai.memory.memory_scope import MemoryScope, MemorySlice
+from crewai.memory.unified_memory import Memory
 from crewai.rag.embeddings.types import EmbedderConfig
 from crewai.security.security_config import SecurityConfig
+from crewai.skills.models import Skill
 from crewai.tools.base_tool import BaseTool, Tool
+from crewai.types.callback import SerializableCallable
 from crewai.utilities.config import process_config
 from crewai.utilities.i18n import I18N, get_i18n
 from crewai.utilities.logger import Logger
@@ -179,7 +185,7 @@ class BaseAgent(BaseModel, ABC, metaclass=AgentMeta):
         default=None,
         description="Knowledge sources for the agent.",
     )
-    knowledge_storage: Any | None = Field(
+    knowledge_storage: InstanceOf[BaseKnowledgeStorage] | None = Field(
         default=None,
         description="Custom knowledge storage for the agent.",
     )
@@ -187,7 +193,7 @@ class BaseAgent(BaseModel, ABC, metaclass=AgentMeta):
         default_factory=SecurityConfig,
         description="Security configuration for the agent, including fingerprinting.",
     )
-    callbacks: list[Callable[[Any], Any]] = Field(
+    callbacks: list[SerializableCallable] = Field(
         default_factory=list, description="Callbacks to be used for the agent"
     )
     adapted_agent: bool = Field(
@@ -205,7 +211,7 @@ class BaseAgent(BaseModel, ABC, metaclass=AgentMeta):
         default=None,
         description="List of MCP server references. Supports 'https://server.com/path' for external servers and bare slugs like 'notion' for connected MCP integrations. Use '#tool_name' suffix for specific tools.",
     )
-    memory: Any = Field(
+    memory: bool | Memory | MemoryScope | MemorySlice | None = Field(
         default=None,
         description=(
             "Enable agent memory. Pass True for default Memory(), "
@@ -213,6 +219,11 @@ class BaseAgent(BaseModel, ABC, metaclass=AgentMeta):
             "If not set, falls back to crew memory."
         ),
     )
+    skills: list[Path | Skill] | None = Field(
+        default=None,
+        description="Agent Skills. Accepts paths for discovery or pre-loaded Skill objects.",
+        min_length=1,
+    )
 
     @model_validator(mode="before")
     @classmethod
@@ -496,3 +507,6 @@ class BaseAgent(BaseModel, ABC, metaclass=AgentMeta):
 
     def set_knowledge(self, crew_embedder: EmbedderConfig | None = None) -> None:
         pass
+
+    def set_skills(self, resolved_crew_skills: list[Any] | None = None) -> None:
+        pass

lib/crewai/src/crewai/agents/agent_builder/base_agent_executor_mixin.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from crewai.agents.parser import AgentFinish
+from crewai.memory.utils import sanitize_scope_name
 from crewai.utilities.printer import Printer
 from crewai.utilities.string_utils import sanitize_tool_name
 
@@ -26,7 +27,12 @@ class CrewAgentExecutorMixin:
     _printer: Printer = Printer()
 
     def _save_to_memory(self, output: AgentFinish) -> None:
-        """Save task result to unified memory (memory or crew._memory)."""
+        """Save task result to unified memory (memory or crew._memory).
+
+        Extends the memory's root_scope with agent-specific path segment
+        (e.g., '/crew/research-crew/agent/researcher') so that agent memories
+        are scoped hierarchically under their crew.
+        """
         memory = getattr(self.agent, "memory", None) or (
             getattr(self.crew, "_memory", None) if self.crew else None
         )
@@ -43,6 +49,21 @@ class CrewAgentExecutorMixin:
             )
             extracted = memory.extract_memories(raw)
             if extracted:
-                memory.remember_many(extracted, agent_role=self.agent.role)
+                # Get the memory's existing root_scope
+                base_root = getattr(memory, "root_scope", None)
+
+                if isinstance(base_root, str) and base_root:
+                    # Memory has a root_scope — extend it with agent info
+                    agent_role = self.agent.role or "unknown"
+                    sanitized_role = sanitize_scope_name(agent_role)
+                    agent_root = f"{base_root.rstrip('/')}/agent/{sanitized_role}"
+                    if not agent_root.startswith("/"):
+                        agent_root = "/" + agent_root
+                    memory.remember_many(
+                        extracted, agent_role=self.agent.role, root_scope=agent_root
+                    )
+                else:
+                    # No base root_scope — don't inject one, preserve backward compat
+                    memory.remember_many(extracted, agent_role=self.agent.role)
         except Exception as e:
             self.agent._logger.log("error", f"Failed to save to memory: {e}")

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

@@ -948,7 +948,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         )
         error_event_emitted = False
 
-        track_delegation_if_needed(func_name, args_dict, self.task)
+        track_delegation_if_needed(func_name, args_dict or {}, self.task)
 
         structured_tool: CrewStructuredTool | None = None
         if original_tool is not None:
@@ -965,7 +965,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         hook_blocked = False
         before_hook_context = ToolCallHookContext(
             tool_name=func_name,
-            tool_input=args_dict,
+            tool_input=args_dict or {},
             tool=structured_tool,  # type: ignore[arg-type]
             agent=self.agent,
             task=self.task,
@@ -991,7 +991,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             result = f"Tool '{func_name}' has reached its usage limit of {original_tool.max_usage_count} times and cannot be used anymore."
         elif not from_cache and func_name in available_functions:
             try:
-                raw_result = available_functions[func_name](**args_dict)
+                raw_result = available_functions[func_name](**(args_dict or {}))
 
                 if self.tools_handler and self.tools_handler.cache:
                     should_cache = True
@@ -1030,7 +1030,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
 
         after_hook_context = ToolCallHookContext(
             tool_name=func_name,
-            tool_input=args_dict,
+            tool_input=args_dict or {},
             tool=structured_tool,  # type: ignore[arg-type]
             agent=self.agent,
             task=self.task,

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

@@ -22,6 +22,7 @@ from crewai.cli.replay_from_task import replay_task_command
 from crewai.cli.reset_memories_command import reset_memories_command
 from crewai.cli.run_crew import run_crew
 from crewai.cli.settings.main import SettingsCommand
+from crewai.cli.shared.token_manager import TokenManager
 from crewai.cli.tools.main import ToolCommand
 from crewai.cli.train_crew import train_crew
 from crewai.cli.triggers.main import TriggersCommand
@@ -34,7 +35,7 @@ from crewai.memory.storage.kickoff_task_outputs_storage import (
 
 @click.group()
 @click.version_option(get_version("crewai"))
-def crewai():
+def crewai() -> None:
     """Top-level command group for crewai."""
 
 
@@ -45,7 +46,7 @@ def crewai():
     ),
 )
 @click.argument("uv_args", nargs=-1, type=click.UNPROCESSED)
-def uv(uv_args):
+def uv(uv_args: tuple[str, ...]) -> None:
     """A wrapper around uv commands that adds custom tool authentication through env vars."""
     env = os.environ.copy()
     try:
@@ -83,7 +84,9 @@ def uv(uv_args):
 @click.argument("name")
 @click.option("--provider", type=str, help="The provider to use for the crew")
 @click.option("--skip_provider", is_flag=True, help="Skip provider validation")
-def create(type, name, provider, skip_provider=False):
+def create(
+    type: str, name: str, provider: str | None, skip_provider: bool = False
+) -> None:
     """Create a new crew, or flow."""
     if type == "crew":
         create_crew(name, provider, skip_provider)
@@ -97,7 +100,7 @@ def create(type, name, provider, skip_provider=False):
 @click.option(
     "--tools", is_flag=True, help="Show the installed version of crewai tools"
 )
-def version(tools):
+def version(tools: bool) -> None:
     """Show the installed version of crewai."""
     try:
         crewai_version = get_version("crewai")
@@ -128,7 +131,7 @@ def version(tools):
     default="trained_agents_data.pkl",
     help="Path to a custom file for training",
 )
-def train(n_iterations: int, filename: str):
+def train(n_iterations: int, filename: str) -> None:
     """Train the crew."""
     click.echo(f"Training the Crew for {n_iterations} iterations")
     train_crew(n_iterations, filename)
@@ -334,7 +337,7 @@ def memory(
     default="gpt-4o-mini",
     help="LLM Model to run the tests on the Crew. For now only accepting only OpenAI models.",
 )
-def test(n_iterations: int, model: str):
+def test(n_iterations: int, model: str) -> None:
     """Test the crew and evaluate the results."""
     click.echo(f"Testing the crew for {n_iterations} iterations with model {model}")
     evaluate_crew(n_iterations, model)
@@ -347,46 +350,62 @@ def test(n_iterations: int, model: str):
     )
 )
 @click.pass_context
-def install(context):
+def install(context: click.Context) -> None:
     """Install the Crew."""
     install_crew(context.args)
 
 
 @crewai.command()
-def run():
+def run() -> None:
     """Run the Crew."""
     run_crew()
 
 
 @crewai.command()
-def update():
+def update() -> None:
     """Update the pyproject.toml of the Crew project to use uv."""
     update_crew()
 
 
 @crewai.command()
-def login():
+def login() -> None:
     """Sign Up/Login to CrewAI AMP."""
     Settings().clear_user_settings()
     AuthenticationCommand().login()
 
 
+@crewai.command()
+@click.option(
+    "--reset", is_flag=True, help="Also reset all CLI configuration to defaults"
+)
+def logout(reset: bool) -> None:
+    """Logout from CrewAI AMP."""
+    settings = Settings()
+    if reset:
+        settings.reset()
+        click.echo("Successfully logged out and reset all CLI configuration.")
+    else:
+        TokenManager().clear_tokens()
+        settings.clear_user_settings()
+        click.echo("Successfully logged out from CrewAI AMP.")
+
+
 # DEPLOY CREWAI+ COMMANDS
 @crewai.group()
-def deploy():
+def deploy() -> None:
     """Deploy the Crew CLI group."""
 
 
 @deploy.command(name="create")
 @click.option("-y", "--yes", is_flag=True, help="Skip the confirmation prompt")
-def deploy_create(yes: bool):
+def deploy_create(yes: bool) -> None:
     """Create a Crew deployment."""
     deploy_cmd = DeployCommand()
     deploy_cmd.create_crew(yes)
 
 
 @deploy.command(name="list")
-def deploy_list():
+def deploy_list() -> None:
     """List all deployments."""
     deploy_cmd = DeployCommand()
     deploy_cmd.list_crews()
@@ -394,7 +413,7 @@ def deploy_list():
 
 @deploy.command(name="push")
 @click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
-def deploy_push(uuid: str | None):
+def deploy_push(uuid: str | None) -> None:
     """Deploy the Crew."""
     deploy_cmd = DeployCommand()
     deploy_cmd.deploy(uuid=uuid)
@@ -402,7 +421,7 @@ def deploy_push(uuid: str | None):
 
 @deploy.command(name="status")
 @click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
-def deply_status(uuid: str | None):
+def deply_status(uuid: str | None) -> None:
     """Get the status of a deployment."""
     deploy_cmd = DeployCommand()
     deploy_cmd.get_crew_status(uuid=uuid)
@@ -410,7 +429,7 @@ def deply_status(uuid: str | None):
 
 @deploy.command(name="logs")
 @click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
-def deploy_logs(uuid: str | None):
+def deploy_logs(uuid: str | None) -> None:
     """Get the logs of a deployment."""
     deploy_cmd = DeployCommand()
     deploy_cmd.get_crew_logs(uuid=uuid)
@@ -418,27 +437,27 @@ def deploy_logs(uuid: str | None):
 
 @deploy.command(name="remove")
 @click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
-def deploy_remove(uuid: str | None):
+def deploy_remove(uuid: str | None) -> None:
     """Remove a deployment."""
     deploy_cmd = DeployCommand()
     deploy_cmd.remove_crew(uuid=uuid)
 
 
 @crewai.group()
-def tool():
+def tool() -> None:
     """Tool Repository related commands."""
 
 
 @tool.command(name="create")
 @click.argument("handle")
-def tool_create(handle: str):
+def tool_create(handle: str) -> None:
     tool_cmd = ToolCommand()
     tool_cmd.create(handle)
 
 
 @tool.command(name="install")
 @click.argument("handle")
-def tool_install(handle: str):
+def tool_install(handle: str) -> None:
     tool_cmd = ToolCommand()
     tool_cmd.login()
     tool_cmd.install(handle)
@@ -454,26 +473,26 @@ def tool_install(handle: str):
 )
 @click.option("--public", "is_public", flag_value=True, default=False)
 @click.option("--private", "is_public", flag_value=False)
-def tool_publish(is_public: bool, force: bool):
+def tool_publish(is_public: bool, force: bool) -> None:
     tool_cmd = ToolCommand()
     tool_cmd.login()
     tool_cmd.publish(is_public, force)
 
 
 @crewai.group()
-def flow():
+def flow() -> None:
     """Flow related commands."""
 
 
 @flow.command(name="kickoff")
-def flow_run():
+def flow_run() -> None:
     """Kickoff the Flow."""
     click.echo("Running the Flow")
     kickoff_flow()
 
 
 @flow.command(name="plot")
-def flow_plot():
+def flow_plot() -> None:
     """Plot the Flow."""
     click.echo("Plotting the Flow")
     plot_flow()
@@ -481,19 +500,19 @@ def flow_plot():
 
 @flow.command(name="add-crew")
 @click.argument("crew_name")
-def flow_add_crew(crew_name):
+def flow_add_crew(crew_name: str) -> None:
     """Add a crew to an existing flow."""
     click.echo(f"Adding crew {crew_name} to the flow")
     add_crew_to_flow(crew_name)
 
 
 @crewai.group()
-def triggers():
+def triggers() -> None:
     """Trigger related commands. Use 'crewai triggers list' to see available triggers, or 'crewai triggers run app_slug/trigger_slug' to execute."""
 
 
 @triggers.command(name="list")
-def triggers_list():
+def triggers_list() -> None:
     """List all available triggers from integrations."""
     triggers_cmd = TriggersCommand()
     triggers_cmd.list_triggers()
@@ -501,14 +520,14 @@ def triggers_list():
 
 @triggers.command(name="run")
 @click.argument("trigger_path")
-def triggers_run(trigger_path: str):
+def triggers_run(trigger_path: str) -> None:
     """Execute crew with trigger payload. Format: app_slug/trigger_slug"""
     triggers_cmd = TriggersCommand()
     triggers_cmd.execute_with_trigger(trigger_path)
 
 
 @crewai.command()
-def chat():
+def chat() -> None:
     """
     Start a conversation with the Crew, collecting user-supplied inputs,
     and using the Chat LLM to generate responses.
@@ -521,12 +540,12 @@ def chat():
 
 
 @crewai.group(invoke_without_command=True)
-def org():
+def org() -> None:
     """Organization management commands."""
 
 
 @org.command("list")
-def org_list():
+def org_list() -> None:
     """List available organizations."""
     org_command = OrganizationCommand()
     org_command.list()
@@ -534,39 +553,39 @@ def org_list():
 
 @org.command()
 @click.argument("id")
-def switch(id):
+def switch(id: str) -> None:
     """Switch to a specific organization."""
     org_command = OrganizationCommand()
     org_command.switch(id)
 
 
 @org.command()
-def current():
+def current() -> None:
     """Show current organization when 'crewai org' is called without subcommands."""
     org_command = OrganizationCommand()
     org_command.current()
 
 
 @crewai.group()
-def enterprise():
+def enterprise() -> None:
     """Enterprise Configuration commands."""
 
 
 @enterprise.command("configure")
 @click.argument("enterprise_url")
-def enterprise_configure(enterprise_url: str):
+def enterprise_configure(enterprise_url: str) -> None:
     """Configure CrewAI AMP OAuth2 settings from the provided Enterprise URL."""
     enterprise_command = EnterpriseConfigureCommand()
     enterprise_command.configure(enterprise_url)
 
 
 @crewai.group()
-def config():
+def config() -> None:
     """CLI Configuration commands."""
 
 
 @config.command("list")
-def config_list():
+def config_list() -> None:
     """List all CLI configuration parameters."""
     config_command = SettingsCommand()
     config_command.list()
@@ -575,26 +594,26 @@ def config_list():
 @config.command("set")
 @click.argument("key")
 @click.argument("value")
-def config_set(key: str, value: str):
+def config_set(key: str, value: str) -> None:
     """Set a CLI configuration parameter."""
     config_command = SettingsCommand()
     config_command.set(key, value)
 
 
 @config.command("reset")
-def config_reset():
+def config_reset() -> None:
     """Reset all CLI configuration parameters to default values."""
     config_command = SettingsCommand()
     config_command.reset_all_settings()
 
 
 @crewai.group()
-def env():
+def env() -> None:
     """Environment variable commands."""
 
 
 @env.command("view")
-def env_view():
+def env_view() -> None:
     """View tracing-related environment variables."""
     import os
     from pathlib import Path
@@ -672,12 +691,12 @@ def env_view():
 
 
 @crewai.group()
-def traces():
+def traces() -> None:
     """Trace collection management commands."""
 
 
 @traces.command("enable")
-def traces_enable():
+def traces_enable() -> None:
     """Enable trace collection for crew/flow executions."""
     from rich.console import Console
     from rich.panel import Panel
@@ -700,7 +719,7 @@ def traces_enable():
 
 
 @traces.command("disable")
-def traces_disable():
+def traces_disable() -> None:
     """Disable trace collection for crew/flow executions."""
     from rich.console import Console
     from rich.panel import Panel
@@ -723,7 +742,7 @@ def traces_disable():
 
 
 @traces.command("status")
-def traces_status():
+def traces_status() -> None:
     """Show current trace collection status."""
     import os
 

lib/crewai/src/crewai/cli/config.py

@@ -77,7 +77,7 @@ CLI_SETTINGS_KEYS = [
 ]
 
 # Default values for CLI settings
-DEFAULT_CLI_SETTINGS = {
+DEFAULT_CLI_SETTINGS: dict[str, Any] = {
     "enterprise_base_url": DEFAULT_CREWAI_ENTERPRISE_URL,
     "oauth2_provider": CREWAI_ENTERPRISE_DEFAULT_OAUTH2_PROVIDER,
     "oauth2_audience": CREWAI_ENTERPRISE_DEFAULT_OAUTH2_AUDIENCE,

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

@@ -6,7 +6,7 @@ import click
 from crewai.telemetry import Telemetry
 
 
-def create_flow(name):
+def create_flow(name: str) -> None:
     """Create a new flow."""
     folder_name = name.replace(" ", "_").replace("-", "_").lower()
     class_name = name.replace("_", " ").replace("-", " ").title().replace(" ", "")
@@ -49,7 +49,7 @@ def create_flow(name):
         "poem_crew",
     ]
 
-    def process_file(src_file, dst_file):
+    def process_file(src_file: Path, dst_file: Path) -> None:
         if src_file.suffix in [".pyc", ".pyo", ".pyd"]:
             return
 

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

@@ -15,7 +15,7 @@ class DeployCommand(BaseCommand, PlusAPIMixin):
     A class to handle deployment-related operations for CrewAI projects.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         """
         Initialize the DeployCommand with project name and API client.
         """
@@ -67,7 +67,7 @@ class DeployCommand(BaseCommand, PlusAPIMixin):
         Args:
             uuid (Optional[str]): The UUID of the crew to deploy.
         """
-        self._start_deployment_span = self._telemetry.start_deployment_span(uuid)
+        self._telemetry.start_deployment_span(uuid)
         console.print("Starting deployment...", style="bold blue")
         if uuid:
             response = self.plus_api_client.deploy_by_uuid(uuid)
@@ -84,9 +84,7 @@ class DeployCommand(BaseCommand, PlusAPIMixin):
         """
         Create a new crew deployment.
         """
-        self._create_crew_deployment_span = (
-            self._telemetry.create_crew_deployment_span()
-        )
+        self._telemetry.create_crew_deployment_span()
         console.print("Creating deployment...", style="bold blue")
         env_vars = fetch_and_json_env_file()
 
@@ -236,7 +234,7 @@ class DeployCommand(BaseCommand, PlusAPIMixin):
             uuid (Optional[str]): The UUID of the crew to get logs for.
             log_type (str): The type of logs to retrieve (default: "deployment").
         """
-        self._get_crew_logs_span = self._telemetry.get_crew_logs_span(uuid, log_type)
+        self._telemetry.get_crew_logs_span(uuid, log_type)
         console.print(f"Fetching {log_type} logs...", style="bold blue")
 
         if uuid:
@@ -257,7 +255,7 @@ class DeployCommand(BaseCommand, PlusAPIMixin):
         Args:
             uuid (Optional[str]): The UUID of the crew to remove.
         """
-        self._remove_crew_span = self._telemetry.remove_crew_span(uuid)
+        self._telemetry.remove_crew_span(uuid)
         console.print("Removing deployment...", style="bold blue")
 
         if uuid:

lib/crewai/src/crewai/cli/memory_tui.py

@@ -173,13 +173,13 @@ class MemoryTUI(App[None]):
         info = self._memory.info("/")
         tree.root.label = f"/ ({info.record_count} records)"
         tree.root.data = "/"
-        self._add_children(tree.root, "/", depth=0, max_depth=3)
+        self._add_scope_children(tree.root, "/", depth=0, max_depth=3)
         tree.root.expand()
         return tree
 
-    def _add_children(
+    def _add_scope_children(
         self,
-        parent_node: Tree.Node[str],
+        parent_node: Any,
         path: str,
         depth: int,
         max_depth: int,
@@ -191,7 +191,7 @@ class MemoryTUI(App[None]):
             child_info = self._memory.info(child)
             label = f"{child} ({child_info.record_count})"
             node = parent_node.add(label, data=child)
-            self._add_children(node, child, depth + 1, max_depth)
+            self._add_scope_children(node, child, depth + 1, max_depth)
 
     # -- Populating the OptionList -------------------------------------------
 

lib/crewai/src/crewai/cli/reset_memories_command.py

@@ -1,4 +1,5 @@
 import subprocess
+from typing import Any
 
 import click
 
@@ -6,7 +7,7 @@ from crewai.cli.utils import get_crews, get_flows
 from crewai.flow import Flow
 
 
-def _reset_flow_memory(flow: Flow) -> None:
+def _reset_flow_memory(flow: Flow[Any]) -> None:
     """Reset memory for a single flow instance.
 
     Handles Memory, MemoryScope (both have .reset()), and MemorySlice

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.11.0rc2"
+    "crewai[tools]==1.11.1"
 ]
 
 [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.11.0rc2"
+    "crewai[tools]==1.11.1"
 ]
 
 [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.11.0rc2"
+    "crewai[tools]==1.11.1"
 ]
 
 [tool.crewai]

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

@@ -16,7 +16,7 @@ class TriggersCommand(BaseCommand, PlusAPIMixin):
     A class to handle trigger-related operations for CrewAI projects.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         BaseCommand.__init__(self)
         PlusAPIMixin.__init__(self, telemetry=self._telemetry)
 

lib/crewai/src/crewai/cli/update_crew.py

@@ -1,5 +1,6 @@
 import os
 import shutil
+from typing import Any
 
 import tomli_w
 
@@ -11,7 +12,7 @@ def update_crew() -> None:
     migrate_pyproject("pyproject.toml", "pyproject.toml")
 
 
-def migrate_pyproject(input_file, output_file):
+def migrate_pyproject(input_file: str, output_file: str) -> None:
     """
     Migrate the pyproject.toml to the new format.
 
@@ -23,8 +24,7 @@ def migrate_pyproject(input_file, output_file):
     # Read the input pyproject.toml
     pyproject_data = read_toml()
 
-    # Initialize the new project structure
-    new_pyproject = {
+    new_pyproject: dict[str, Any] = {
         "project": {},
         "build-system": {"requires": ["hatchling"], "build-backend": "hatchling.build"},
     }

lib/crewai/src/crewai/cli/utils.py

@@ -386,7 +386,7 @@ def fetch_crews(module_attr: Any) -> list[Crew]:
     return crew_instances
 
 
-def get_flow_instance(module_attr: Any) -> Flow | None:
+def get_flow_instance(module_attr: Any) -> Flow[Any] | None:
     """Check if a module attribute is a user-defined Flow subclass and return an instance.
 
     Args:
@@ -413,7 +413,7 @@ _SKIP_DIRS = frozenset(
 )
 
 
-def get_flows(flow_path: str = "main.py") -> list[Flow]:
+def get_flows(flow_path: str = "main.py") -> list[Flow[Any]]:
     """Get the flow instances from project files.
 
     Walks the project directory looking for files matching ``flow_path``
@@ -427,7 +427,7 @@ def get_flows(flow_path: str = "main.py") -> list[Flow]:
     Returns:
         A list of discovered Flow instances.
     """
-    flow_instances: list[Flow] = []
+    flow_instances: list[Flow[Any]] = []
     try:
         current_dir = os.getcwd()
         if current_dir not in sys.path:

lib/crewai/src/crewai/crew.py

@@ -6,6 +6,7 @@ from concurrent.futures import Future
 from copy import copy as shallow_copy
 from hashlib import md5
 import json
+from pathlib import Path
 import re
 from typing import (
     TYPE_CHECKING,
@@ -35,6 +36,7 @@ from typing_extensions import Self
 
 if TYPE_CHECKING:
     from crewai_files import FileInput
+    from opentelemetry.trace import Span
 
 try:
     from crewai_files import get_supported_content_types
@@ -83,21 +85,26 @@ from crewai.knowledge.knowledge import Knowledge
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
 from crewai.llm import LLM
 from crewai.llms.base_llm import BaseLLM
+from crewai.memory.memory_scope import MemoryScope, MemorySlice
+from crewai.memory.unified_memory import Memory
 from crewai.process import Process
 from crewai.rag.embeddings.types import EmbedderConfig
 from crewai.rag.types import SearchResult
 from crewai.security.fingerprint import Fingerprint
 from crewai.security.security_config import SecurityConfig
+from crewai.skills.models import Skill
 from crewai.task import Task
 from crewai.tasks.conditional_task import ConditionalTask
 from crewai.tasks.task_output import TaskOutput
 from crewai.tools.agent_tools.agent_tools import AgentTools
 from crewai.tools.agent_tools.read_file_tool import ReadFileTool
 from crewai.tools.base_tool import BaseTool
+from crewai.types.callback import SerializableCallable
 from crewai.types.streaming import CrewStreamingOutput
 from crewai.types.usage_metrics import UsageMetrics
 from crewai.utilities.constants import NOT_SPECIFIED, TRAINING_DATA_FILE
 from crewai.utilities.crew.models import CrewContext
+from crewai.utilities.env import get_env_context
 from crewai.utilities.evaluators.crew_evaluator_handler import CrewEvaluator
 from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
 from crewai.utilities.file_handler import FileHandler
@@ -165,12 +172,12 @@ class Crew(FlowTrackable, BaseModel):
     """
 
     __hash__ = object.__hash__
-    _execution_span: Any = PrivateAttr()
+    _execution_span: Span | None = PrivateAttr()
     _rpm_controller: RPMController = PrivateAttr()
     _logger: Logger = PrivateAttr()
     _file_handler: FileHandler = PrivateAttr()
     _cache_handler: InstanceOf[CacheHandler] = PrivateAttr(default_factory=CacheHandler)
-    _memory: Any = PrivateAttr(default=None)  # Unified Memory | MemoryScope
+    _memory: Memory | MemoryScope | MemorySlice | None = PrivateAttr(default=None)
     _train: bool | None = PrivateAttr(default=False)
     _train_iteration: int | None = PrivateAttr()
     _inputs: dict[str, Any] | None = PrivateAttr(default=None)
@@ -188,7 +195,7 @@ class Crew(FlowTrackable, BaseModel):
     agents: list[BaseAgent] = Field(default_factory=list)
     process: Process = Field(default=Process.sequential)
     verbose: bool = Field(default=False)
-    memory: bool | Any = Field(
+    memory: bool | Memory | MemoryScope | MemorySlice | None = Field(
         default=False,
         description=(
             "Enable crew memory. Pass True for default Memory(), "
@@ -203,36 +210,34 @@ class Crew(FlowTrackable, BaseModel):
         default=None,
         description="Metrics for the LLM usage during all tasks execution.",
     )
-    manager_llm: str | InstanceOf[BaseLLM] | Any | None = Field(
+    manager_llm: str | InstanceOf[BaseLLM] | None = Field(
         description="Language model that will run the agent.", default=None
     )
     manager_agent: BaseAgent | None = Field(
         description="Custom agent that will be used as manager.", default=None
     )
-    function_calling_llm: str | InstanceOf[LLM] | Any | None = Field(
+    function_calling_llm: str | InstanceOf[LLM] | None = Field(
         description="Language model that will run the agent.", default=None
     )
     config: Json[dict[str, Any]] | dict[str, Any] | None = Field(default=None)
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     share_crew: bool | None = Field(default=False)
-    step_callback: Any | None = Field(
+    step_callback: SerializableCallable | None = Field(
         default=None,
         description="Callback to be executed after each step for all agents execution.",
     )
-    task_callback: Any | None = Field(
+    task_callback: SerializableCallable | None = Field(
         default=None,
         description="Callback to be executed after each task for all agents execution.",
     )
-    before_kickoff_callbacks: list[
-        Callable[[dict[str, Any] | None], dict[str, Any] | None]
-    ] = Field(
+    before_kickoff_callbacks: list[SerializableCallable] = Field(
         default_factory=list,
         description=(
             "List of callbacks to be executed before crew kickoff. "
             "It may be used to adjust inputs before the crew is executed."
         ),
     )
-    after_kickoff_callbacks: list[Callable[[CrewOutput], CrewOutput]] = Field(
+    after_kickoff_callbacks: list[SerializableCallable] = Field(
         default_factory=list,
         description=(
             "List of callbacks to be executed after crew kickoff. "
@@ -291,6 +296,11 @@ class Crew(FlowTrackable, BaseModel):
         default=None,
         description="Knowledge for the crew.",
     )
+    skills: list[Path | Skill] | None = Field(
+        default=None,
+        description="Skill search paths or pre-loaded Skill objects applied to all agents in the crew.",
+    )
+
     security_config: SecurityConfig = Field(
         default_factory=SecurityConfig,
         description="Security configuration for the crew, including fingerprinting.",
@@ -348,13 +358,24 @@ class Crew(FlowTrackable, BaseModel):
             self._file_handler = FileHandler(self.output_log_file)
         self._rpm_controller = RPMController(max_rpm=self.max_rpm, logger=self._logger)
         if self.function_calling_llm and not isinstance(self.function_calling_llm, LLM):
-            self.function_calling_llm = create_llm(self.function_calling_llm)
+            self.function_calling_llm = create_llm(self.function_calling_llm)  # type: ignore[assignment]
 
         return self
 
     @model_validator(mode="after")
     def create_crew_memory(self) -> Crew:
-        """Initialize unified memory, respecting crew embedder config."""
+        """Initialize unified memory, respecting crew embedder config.
+
+        When memory is enabled, sets a hierarchical root_scope based on the
+        crew name (e.g. '/crew/research-crew') so that all memories saved by
+        this crew and its agents are organized under a consistent namespace.
+        """
+        from crewai.memory.utils import sanitize_scope_name
+
+        # Compute sanitized crew name for root_scope
+        crew_name = sanitize_scope_name(self.name or "crew")
+        crew_root_scope = f"/crew/{crew_name}"
+
         if self.memory is True:
             from crewai.memory.unified_memory import Memory
 
@@ -362,10 +383,11 @@ class Crew(FlowTrackable, BaseModel):
             if self.embedder is not None:
                 from crewai.rag.embeddings.factory import build_embedder
 
-                embedder = build_embedder(self.embedder)
-            self._memory = Memory(embedder=embedder)
+                embedder = build_embedder(cast(dict[str, Any], self.embedder))
+            self._memory = Memory(embedder=embedder, root_scope=crew_root_scope)
         elif self.memory:
             # User passed a Memory / MemoryScope / MemorySlice instance
+            # Respect user's configuration — don't auto-set root_scope
             self._memory = self.memory
         else:
             self._memory = None
@@ -679,6 +701,7 @@ class Crew(FlowTrackable, BaseModel):
         Returns:
             CrewOutput or CrewStreamingOutput if streaming is enabled.
         """
+        get_env_context()
         if self.stream:
             enable_agent_streaming(self.agents)
             ctx = StreamingContext()

lib/crewai/src/crewai/crews/crew_output.py

@@ -45,14 +45,14 @@ class CrewOutput(BaseModel):
             output_dict.update(self.pydantic.model_dump())
         return output_dict
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: str) -> Any:
         if self.pydantic and hasattr(self.pydantic, key):
             return getattr(self.pydantic, key)
         if self.json_dict and key in self.json_dict:
             return self.json_dict[key]
         raise KeyError(f"Key '{key}' not found in CrewOutput.")
 
-    def __str__(self):
+    def __str__(self) -> str:
         if self.pydantic:
             return str(self.pydantic)
         if self.json_dict:

lib/crewai/src/crewai/crews/utils.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import Callable, Coroutine, Iterable, Mapping
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from opentelemetry import baggage
@@ -11,6 +12,8 @@ from opentelemetry import baggage
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.crews.crew_output import CrewOutput
 from crewai.rag.embeddings.types import EmbedderConfig
+from crewai.skills.loader import activate_skill, discover_skills
+from crewai.skills.models import INSTRUCTIONS, Skill as SkillModel
 from crewai.types.streaming import CrewStreamingOutput, FlowStreamingOutput
 from crewai.utilities.file_store import store_files
 from crewai.utilities.streaming import (
@@ -51,6 +54,30 @@ def enable_agent_streaming(agents: Iterable[BaseAgent]) -> None:
             agent.llm.stream = True
 
 
+def _resolve_crew_skills(crew: Crew) -> list[SkillModel] | None:
+    """Resolve crew-level skill paths once so agents don't repeat the work."""
+    if not isinstance(crew.skills, list) or not crew.skills:
+        return None
+
+    resolved: list[SkillModel] = []
+    seen: set[str] = set()
+    for item in crew.skills:
+        if isinstance(item, Path):
+            for skill in discover_skills(item):
+                if skill.name not in seen:
+                    seen.add(skill.name)
+                    resolved.append(activate_skill(skill))
+        elif isinstance(item, SkillModel):
+            if item.name not in seen:
+                seen.add(item.name)
+                resolved.append(
+                    activate_skill(item)
+                    if item.disclosure_level < INSTRUCTIONS
+                    else item
+                )
+    return resolved
+
+
 def setup_agents(
     crew: Crew,
     agents: Iterable[BaseAgent],
@@ -67,9 +94,12 @@ def setup_agents(
         function_calling_llm: Default function calling LLM for agents.
         step_callback: Default step callback for agents.
     """
+    resolved_crew_skills = _resolve_crew_skills(crew)
+
     for agent in agents:
         agent.crew = crew
         agent.set_knowledge(crew_embedder=embedder)
+        agent.set_skills(resolved_crew_skills=resolved_crew_skills)
         if not agent.function_calling_llm:  # type: ignore[attr-defined]
             agent.function_calling_llm = function_calling_llm  # type: ignore[attr-defined]
         if not agent.step_callback:  # type: ignore[attr-defined]

lib/crewai/src/crewai/events/__init__.py

@@ -88,6 +88,14 @@ from crewai.events.types.reasoning_events import (
     AgentReasoningStartedEvent,
     ReasoningEvent,
 )
+from crewai.events.types.skill_events import (
+    SkillActivatedEvent,
+    SkillDiscoveryCompletedEvent,
+    SkillDiscoveryStartedEvent,
+    SkillEvent,
+    SkillLoadFailedEvent,
+    SkillLoadedEvent,
+)
 from crewai.events.types.task_events import (
     TaskCompletedEvent,
     TaskEvaluationEvent,
@@ -186,6 +194,12 @@ __all__ = [
     "MethodExecutionFinishedEvent",
     "MethodExecutionStartedEvent",
     "ReasoningEvent",
+    "SkillActivatedEvent",
+    "SkillDiscoveryCompletedEvent",
+    "SkillDiscoveryStartedEvent",
+    "SkillEvent",
+    "SkillLoadFailedEvent",
+    "SkillLoadedEvent",
     "TaskCompletedEvent",
     "TaskEvaluationEvent",
     "TaskFailedEvent",

lib/crewai/src/crewai/events/event_listener.py

@@ -34,6 +34,12 @@ from crewai.events.types.crew_events import (
     CrewTrainFailedEvent,
     CrewTrainStartedEvent,
 )
+from crewai.events.types.env_events import (
+    CCEnvEvent,
+    CodexEnvEvent,
+    CursorEnvEvent,
+    DefaultEnvEvent,
+)
 from crewai.events.types.flow_events import (
     FlowCreatedEvent,
     FlowFinishedEvent,
@@ -143,6 +149,23 @@ class EventListener(BaseEventListener):
     # ----------- CREW EVENTS -----------
 
     def setup_listeners(self, crewai_event_bus: CrewAIEventsBus) -> None:
+
+        @crewai_event_bus.on(CCEnvEvent)
+        def on_cc_env(_: Any, event: CCEnvEvent) -> None:
+            self._telemetry.env_context_span(event.type)
+
+        @crewai_event_bus.on(CodexEnvEvent)
+        def on_codex_env(_: Any, event: CodexEnvEvent) -> None:
+            self._telemetry.env_context_span(event.type)
+
+        @crewai_event_bus.on(CursorEnvEvent)
+        def on_cursor_env(_: Any, event: CursorEnvEvent) -> None:
+            self._telemetry.env_context_span(event.type)
+
+        @crewai_event_bus.on(DefaultEnvEvent)
+        def on_default_env(_: Any, event: DefaultEnvEvent) -> None:
+            self._telemetry.env_context_span(event.type)
+
         @crewai_event_bus.on(CrewKickoffStartedEvent)
         def on_crew_started(source: Any, event: CrewKickoffStartedEvent) -> None:
             self.formatter.handle_crew_started(event.crew_name or "Crew", source.id)

lib/crewai/src/crewai/events/handler_graph.py

@@ -6,6 +6,7 @@ handlers execute in correct order while maximizing parallelism.
 
 from collections import defaultdict, deque
 from collections.abc import Sequence
+from typing import Any
 
 from crewai.events.depends import Depends
 from crewai.events.types.event_bus_types import ExecutionPlan, Handler
@@ -45,7 +46,7 @@ class HandlerGraph:
 
     def __init__(
         self,
-        handlers: dict[Handler, list[Depends]],
+        handlers: dict[Handler, list[Depends[Any]]],
     ) -> None:
         """Initialize the dependency graph.
 
@@ -103,7 +104,7 @@ class HandlerGraph:
 
 def build_execution_plan(
     handlers: Sequence[Handler],
-    dependencies: dict[Handler, list[Depends]],
+    dependencies: dict[Handler, list[Depends[Any]]],
 ) -> ExecutionPlan:
     """Build an execution plan from handlers and their dependencies.
 
@@ -118,7 +119,7 @@ def build_execution_plan(
     Raises:
         CircularDependencyError: If circular dependencies are detected
     """
-    handler_dict: dict[Handler, list[Depends]] = {
+    handler_dict: dict[Handler, list[Depends[Any]]] = {
         h: dependencies.get(h, []) for h in handlers
     }
 

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

@@ -65,9 +65,9 @@ class FirstTimeTraceHandler:
             self._gracefully_fail(f"Error in trace handling: {e}")
             mark_first_execution_completed(user_consented=False)
 
-    def _initialize_backend_and_send_events(self):
+    def _initialize_backend_and_send_events(self) -> None:
         """Initialize backend batch and send collected events."""
-        if not self.batch_manager:
+        if not self.batch_manager or not self.batch_manager.trace_batch_id:
             return
 
         try:
@@ -115,12 +115,13 @@ class FirstTimeTraceHandler:
         except Exception as e:
             self._gracefully_fail(f"Backend initialization failed: {e}")
 
-    def _display_ephemeral_trace_link(self):
+    def _display_ephemeral_trace_link(self) -> None:
         """Display the ephemeral trace link to the user and automatically open browser."""
         console = Console()
 
         try:
-            webbrowser.open(self.ephemeral_url)
+            if self.ephemeral_url:
+                webbrowser.open(self.ephemeral_url)
         except Exception:  # noqa: S110
             pass
 
@@ -158,7 +159,7 @@ To disable tracing later, do any one of these:
         console.print(panel)
         console.print()
 
-    def _show_tracing_declined_message(self):
+    def _show_tracing_declined_message(self) -> None:
         """Show message when user declines tracing."""
         console = Console()
 
@@ -184,15 +185,18 @@ To enable tracing later, do any one of these:
         console.print(panel)
         console.print()
 
-    def _gracefully_fail(self, error_message: str):
+    def _gracefully_fail(self, error_message: str) -> None:
         """Handle errors gracefully without disrupting user experience."""
         console = Console()
         console.print(f"[yellow]Note: {error_message}[/yellow]")
 
         logger.debug(f"First-time trace error: {error_message}")
 
-    def _show_local_trace_message(self):
+    def _show_local_trace_message(self) -> None:
         """Show message when traces were collected locally but couldn't be uploaded."""
+        if self.batch_manager is None:
+            return
+
         console = Console()
 
         panel_content = f"""

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

@@ -58,6 +58,12 @@ from crewai.events.types.crew_events import (
     CrewKickoffFailedEvent,
     CrewKickoffStartedEvent,
 )
+from crewai.events.types.env_events import (
+    CCEnvEvent,
+    CodexEnvEvent,
+    CursorEnvEvent,
+    DefaultEnvEvent,
+)
 from crewai.events.types.flow_events import (
     FlowCreatedEvent,
     FlowFinishedEvent,
@@ -192,6 +198,7 @@ class TraceCollectionListener(BaseEventListener):
         if self._listeners_setup:
             return
 
+        self._register_env_event_handlers(crewai_event_bus)
         self._register_flow_event_handlers(crewai_event_bus)
         self._register_context_event_handlers(crewai_event_bus)
         self._register_action_event_handlers(crewai_event_bus)
@@ -200,6 +207,25 @@ class TraceCollectionListener(BaseEventListener):
 
         self._listeners_setup = True
 
+    def _register_env_event_handlers(self, event_bus: CrewAIEventsBus) -> None:
+        """Register handlers for environment context events."""
+
+        @event_bus.on(CCEnvEvent)
+        def on_cc_env(source: Any, event: CCEnvEvent) -> None:
+            self._handle_action_event("cc_env", source, event)
+
+        @event_bus.on(CodexEnvEvent)
+        def on_codex_env(source: Any, event: CodexEnvEvent) -> None:
+            self._handle_action_event("codex_env", source, event)
+
+        @event_bus.on(CursorEnvEvent)
+        def on_cursor_env(source: Any, event: CursorEnvEvent) -> None:
+            self._handle_action_event("cursor_env", source, event)
+
+        @event_bus.on(DefaultEnvEvent)
+        def on_default_env(source: Any, event: DefaultEnvEvent) -> None:
+            self._handle_action_event("default_env", source, event)
+
     def _register_flow_event_handlers(self, event_bus: CrewAIEventsBus) -> None:
         """Register handlers for flow events."""
 

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

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import Any
+from typing import TYPE_CHECKING, Any, Self
 
 from pydantic import ConfigDict, model_validator
 
@@ -13,6 +13,10 @@ from crewai.tools.base_tool import BaseTool
 from crewai.tools.structured_tool import CrewStructuredTool
 
 
+if TYPE_CHECKING:
+    from crewai.agent.core import Agent
+
+
 class AgentExecutionStartedEvent(BaseEvent):
     """Event emitted when an agent starts executing a task"""
 
@@ -25,16 +29,9 @@ class AgentExecutionStartedEvent(BaseEvent):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     @model_validator(mode="after")
-    def set_fingerprint_data(self):
+    def set_fingerprint_data(self) -> Self:
         """Set fingerprint data from the agent if available."""
-        if hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
-            self.source_fingerprint = self.agent.fingerprint.uuid_str
-            self.source_type = "agent"
-            if (
-                hasattr(self.agent.fingerprint, "metadata")
-                and self.agent.fingerprint.metadata
-            ):
-                self.fingerprint_metadata = self.agent.fingerprint.metadata
+        _set_agent_fingerprint(self, self.agent)
         return self
 
 
@@ -49,16 +46,9 @@ class AgentExecutionCompletedEvent(BaseEvent):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     @model_validator(mode="after")
-    def set_fingerprint_data(self):
+    def set_fingerprint_data(self) -> Self:
         """Set fingerprint data from the agent if available."""
-        if hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
-            self.source_fingerprint = self.agent.fingerprint.uuid_str
-            self.source_type = "agent"
-            if (
-                hasattr(self.agent.fingerprint, "metadata")
-                and self.agent.fingerprint.metadata
-            ):
-                self.fingerprint_metadata = self.agent.fingerprint.metadata
+        _set_agent_fingerprint(self, self.agent)
         return self
 
 
@@ -73,16 +63,9 @@ class AgentExecutionErrorEvent(BaseEvent):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     @model_validator(mode="after")
-    def set_fingerprint_data(self):
+    def set_fingerprint_data(self) -> Self:
         """Set fingerprint data from the agent if available."""
-        if hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
-            self.source_fingerprint = self.agent.fingerprint.uuid_str
-            self.source_type = "agent"
-            if (
-                hasattr(self.agent.fingerprint, "metadata")
-                and self.agent.fingerprint.metadata
-            ):
-                self.fingerprint_metadata = self.agent.fingerprint.metadata
+        _set_agent_fingerprint(self, self.agent)
         return self
 
 
@@ -140,3 +123,14 @@ class AgentEvaluationFailedEvent(BaseEvent):
     iteration: int
     error: str
     type: str = "agent_evaluation_failed"
+
+
+def _set_agent_fingerprint(event: BaseEvent, agent: Agent | BaseAgent) -> None:
+    """Set fingerprint data on an event from an agent object."""
+    from crewai.agent.core import Agent
+
+    if isinstance(agent, Agent) and agent.fingerprint:
+        event.source_fingerprint = agent.fingerprint.uuid_str
+        event.source_type = "agent"
+        if agent.fingerprint.metadata:
+            event.fingerprint_metadata = agent.fingerprint.metadata

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

@@ -15,21 +15,18 @@ class CrewBaseEvent(BaseEvent):
     crew_name: str | None
     crew: Crew | None = None
 
-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
         super().__init__(**data)
-        self.set_crew_fingerprint()
+        self._set_crew_fingerprint()
 
-    def set_crew_fingerprint(self) -> None:
-        if self.crew and hasattr(self.crew, "fingerprint") and self.crew.fingerprint:
+    def _set_crew_fingerprint(self) -> None:
+        if self.crew is not None and self.crew.fingerprint:
             self.source_fingerprint = self.crew.fingerprint.uuid_str
             self.source_type = "crew"
-            if (
-                hasattr(self.crew.fingerprint, "metadata")
-                and self.crew.fingerprint.metadata
-            ):
+            if self.crew.fingerprint.metadata:
                 self.fingerprint_metadata = self.crew.fingerprint.metadata
 
-    def to_json(self, exclude: set[str] | None = None):
+    def to_json(self, exclude: set[str] | None = None) -> Any:
         if exclude is None:
             exclude = set()
         exclude.add("crew")

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

@@ -0,0 +1,36 @@
+from typing import Annotated, Literal
+
+from pydantic import Field, TypeAdapter
+
+from crewai.events.base_events import BaseEvent
+
+
+class CCEnvEvent(BaseEvent):
+    type: Literal["cc_env"] = "cc_env"
+
+
+class CodexEnvEvent(BaseEvent):
+    type: Literal["codex_env"] = "codex_env"
+
+
+class CursorEnvEvent(BaseEvent):
+    type: Literal["cursor_env"] = "cursor_env"
+
+
+class DefaultEnvEvent(BaseEvent):
+    type: Literal["default_env"] = "default_env"
+
+
+EnvContextEvent = Annotated[
+    CCEnvEvent | CodexEnvEvent | CursorEnvEvent | DefaultEnvEvent,
+    Field(discriminator="type"),
+]
+
+env_context_event_adapter: TypeAdapter[EnvContextEvent] = TypeAdapter(EnvContextEvent)
+
+ENV_CONTEXT_EVENT_TYPES: tuple[type[BaseEvent], ...] = (
+    CCEnvEvent,
+    CodexEnvEvent,
+    CursorEnvEvent,
+    DefaultEnvEvent,
+)

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

@@ -11,7 +11,7 @@ class KnowledgeEventBase(BaseEvent):
     agent_role: str | None = None
     agent_id: str | None = None
 
-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
         super().__init__(**data)
         self._set_agent_params(data)
         self._set_task_params(data)

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

@@ -13,7 +13,7 @@ class LLMGuardrailBaseEvent(BaseEvent):
     agent_role: str | None = None
     agent_id: str | None = None
 
-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
         super().__init__(**data)
         self._set_agent_params(data)
         self._set_task_params(data)
@@ -28,10 +28,10 @@ class LLMGuardrailStartedEvent(LLMGuardrailBaseEvent):
     """
 
     type: str = "llm_guardrail_started"
-    guardrail: str | Callable
+    guardrail: str | Callable[..., Any]
     retry_count: int
 
-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
         from crewai.tasks.hallucination_guardrail import HallucinationGuardrail
         from crewai.tasks.llm_guardrail import LLMGuardrail
 
@@ -39,7 +39,7 @@ class LLMGuardrailStartedEvent(LLMGuardrailBaseEvent):
 
         if isinstance(self.guardrail, (LLMGuardrail, HallucinationGuardrail)):
             self.guardrail = self.guardrail.description.strip()
-        elif isinstance(self.guardrail, Callable):
+        elif callable(self.guardrail):
             self.guardrail = getsource(self.guardrail).strip()
 
 

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

@@ -15,7 +15,7 @@ class MCPEvent(BaseEvent):
     from_agent: Any | None = None
     from_task: Any | None = None
 
-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
         super().__init__(**data)
         self._set_agent_params(data)
         self._set_task_params(data)

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

@@ -15,7 +15,7 @@ class ReasoningEvent(BaseEvent):
     agent_id: str | None = None
     from_agent: Any | None = None
 
-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
         super().__init__(**data)
         self._set_task_params(data)
         self._set_agent_params(data)

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

@@ -0,0 +1,62 @@
+"""Skill lifecycle events for the Agent Skills standard.
+
+Events emitted during skill discovery, loading, and activation.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from crewai.events.base_events import BaseEvent
+
+
+class SkillEvent(BaseEvent):
+    """Base event for skill operations."""
+
+    skill_name: str = ""
+    skill_path: Path | None = None
+    from_agent: Any | None = None
+    from_task: Any | None = None
+
+    def __init__(self, **data: Any) -> None:
+        super().__init__(**data)
+        self._set_agent_params(data)
+        self._set_task_params(data)
+
+
+class SkillDiscoveryStartedEvent(SkillEvent):
+    """Event emitted when skill discovery begins."""
+
+    type: str = "skill_discovery_started"
+    search_path: Path
+
+
+class SkillDiscoveryCompletedEvent(SkillEvent):
+    """Event emitted when skill discovery completes."""
+
+    type: str = "skill_discovery_completed"
+    search_path: Path
+    skills_found: int
+    skill_names: list[str]
+
+
+class SkillLoadedEvent(SkillEvent):
+    """Event emitted when a skill is loaded at metadata level."""
+
+    type: str = "skill_loaded"
+    disclosure_level: int = 1
+
+
+class SkillActivatedEvent(SkillEvent):
+    """Event emitted when a skill is activated (promoted to instructions level)."""
+
+    type: str = "skill_activated"
+    disclosure_level: int = 2
+
+
+class SkillLoadFailedEvent(SkillEvent):
+    """Event emitted when skill loading fails."""
+
+    type: str = "skill_load_failed"
+    error: str

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

@@ -4,6 +4,15 @@ from crewai.events.base_events import BaseEvent
 from crewai.tasks.task_output import TaskOutput
 
 
+def _set_task_fingerprint(event: BaseEvent, task: Any) -> None:
+    """Set fingerprint data on an event from a task object."""
+    if task is not None and task.fingerprint:
+        event.source_fingerprint = task.fingerprint.uuid_str
+        event.source_type = "task"
+        if task.fingerprint.metadata:
+            event.fingerprint_metadata = task.fingerprint.metadata
+
+
 class TaskStartedEvent(BaseEvent):
     """Event emitted when a task starts"""
 
@@ -11,17 +20,9 @@ class TaskStartedEvent(BaseEvent):
     context: str | None
     task: Any | None = None
 
-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
         super().__init__(**data)
-        # Set fingerprint data from the task
-        if hasattr(self.task, "fingerprint") and self.task.fingerprint:
-            self.source_fingerprint = self.task.fingerprint.uuid_str
-            self.source_type = "task"
-            if (
-                hasattr(self.task.fingerprint, "metadata")
-                and self.task.fingerprint.metadata
-            ):
-                self.fingerprint_metadata = self.task.fingerprint.metadata
+        _set_task_fingerprint(self, self.task)
 
 
 class TaskCompletedEvent(BaseEvent):
@@ -31,17 +32,9 @@ class TaskCompletedEvent(BaseEvent):
     type: str = "task_completed"
     task: Any | None = None
 
-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
         super().__init__(**data)
-        # Set fingerprint data from the task
-        if hasattr(self.task, "fingerprint") and self.task.fingerprint:
-            self.source_fingerprint = self.task.fingerprint.uuid_str
-            self.source_type = "task"
-            if (
-                hasattr(self.task.fingerprint, "metadata")
-                and self.task.fingerprint.metadata
-            ):
-                self.fingerprint_metadata = self.task.fingerprint.metadata
+        _set_task_fingerprint(self, self.task)
 
 
 class TaskFailedEvent(BaseEvent):
@@ -51,17 +44,9 @@ class TaskFailedEvent(BaseEvent):
     type: str = "task_failed"
     task: Any | None = None
 
-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
         super().__init__(**data)
-        # Set fingerprint data from the task
-        if hasattr(self.task, "fingerprint") and self.task.fingerprint:
-            self.source_fingerprint = self.task.fingerprint.uuid_str
-            self.source_type = "task"
-            if (
-                hasattr(self.task.fingerprint, "metadata")
-                and self.task.fingerprint.metadata
-            ):
-                self.fingerprint_metadata = self.task.fingerprint.metadata
+        _set_task_fingerprint(self, self.task)
 
 
 class TaskEvaluationEvent(BaseEvent):
@@ -71,14 +56,6 @@ class TaskEvaluationEvent(BaseEvent):
     evaluation_type: str
     task: Any | None = None
 
-    def __init__(self, **data):
+    def __init__(self, **data: Any) -> None:
         super().__init__(**data)
-        # Set fingerprint data from the task
-        if hasattr(self.task, "fingerprint") and self.task.fingerprint:
-            self.source_fingerprint = self.task.fingerprint.uuid_str
-            self.source_type = "task"
-            if (
-                hasattr(self.task.fingerprint, "metadata")
-                and self.task.fingerprint.metadata
-            ):
-                self.fingerprint_metadata = self.task.fingerprint.metadata
+        _set_task_fingerprint(self, self.task)

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

@@ -8,7 +8,7 @@ from datetime import datetime
 import inspect
 import json
 import threading
-from typing import TYPE_CHECKING, Any, Literal, cast
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast
 from uuid import uuid4
 
 from pydantic import BaseModel, Field, GetCoreSchemaHandler
@@ -22,7 +22,11 @@ from crewai.agents.parser import (
     AgentFinish,
     OutputParserError,
 )
-from crewai.core.providers.human_input import get_provider
+from crewai.core.providers.human_input import (
+    AsyncExecutorContext,
+    ExecutorContext,
+    get_provider,
+)
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.listeners.tracing.utils import (
     is_tracing_enabled_in_context,
@@ -89,7 +93,7 @@ from crewai.utilities.planning_types import (
     TodoList,
 )
 from crewai.utilities.printer import Printer
-from crewai.utilities.step_execution_context import StepExecutionContext
+from crewai.utilities.step_execution_context import StepExecutionContext, StepResult
 from crewai.utilities.string_utils import sanitize_tool_name
 from crewai.utilities.tool_utils import execute_tool_and_check_finality
 from crewai.utilities.training_handler import CrewTrainingHandler
@@ -105,6 +109,8 @@ if TYPE_CHECKING:
     from crewai.tools.tool_types import ToolResult
     from crewai.utilities.prompts import StandardPromptResult, SystemPromptResult
 
+_RouteT = TypeVar("_RouteT", bound=str)
+
 
 class AgentExecutorState(BaseModel):
     """Structured state for agent executor flow.
@@ -446,29 +452,29 @@ class AgentExecutor(Flow[AgentExecutorState], CrewAgentExecutorMixin):
             step failures reliably trigger replanning rather than being
             silently ignored.
         """
-        config = getattr(self.agent, "planning_config", None)
-        if config is not None and hasattr(config, "reasoning_effort"):
+        config = self.agent.planning_config
+        if config is not None:
             return config.reasoning_effort
         return "medium"
 
     def _get_max_replans(self) -> int:
         """Get max replans from planning config or default to 3."""
-        config = getattr(self.agent, "planning_config", None)
-        if config is not None and hasattr(config, "max_replans"):
+        config = self.agent.planning_config
+        if config is not None:
             return config.max_replans
         return 3
 
     def _get_max_step_iterations(self) -> int:
         """Get max step iterations from planning config or default to 15."""
-        config = getattr(self.agent, "planning_config", None)
-        if config is not None and hasattr(config, "max_step_iterations"):
+        config = self.agent.planning_config
+        if config is not None:
             return config.max_step_iterations
         return 15
 
     def _get_step_timeout(self) -> int | None:
         """Get per-step timeout from planning config or default to None."""
-        config = getattr(self.agent, "planning_config", None)
-        if config is not None and hasattr(config, "step_timeout"):
+        config = self.agent.planning_config
+        if config is not None:
             return config.step_timeout
         return None
 
@@ -1130,9 +1136,9 @@ class AgentExecutor(Flow[AgentExecutorState], CrewAgentExecutorMixin):
         # Process results: store on todos and log, then observe each.
         # asyncio.gather preserves input order, so zip gives us the exact
         # todo ↔ result (or exception) mapping.
-        step_results: list[tuple[TodoItem, object]] = []
+        step_results: list[tuple[TodoItem, StepResult]] = []
         for todo, item in zip(ready, gathered, strict=True):
-            if isinstance(item, Exception):
+            if isinstance(item, BaseException):
                 error_msg = f"Error: {item!s}"
                 todo.result = error_msg
                 self.state.todos.mark_failed(todo.step_number, result=error_msg)
@@ -1143,31 +1149,34 @@ class AgentExecutor(Flow[AgentExecutorState], CrewAgentExecutorMixin):
                     )
             else:
                 _returned_todo, result = item
-                todo.result = result.result
+                step_result = cast(StepResult, result)
+                todo.result = step_result.result
 
                 self.state.execution_log.append(
                     {
                         "type": "step_execution",
                         "step_number": todo.step_number,
-                        "success": result.success,
-                        "result_preview": result.result[:200] if result.result else "",
-                        "error": result.error,
-                        "tool_calls": result.tool_calls_made,
-                        "execution_time": result.execution_time,
+                        "success": step_result.success,
+                        "result_preview": step_result.result[:200]
+                        if step_result.result
+                        else "",
+                        "error": step_result.error,
+                        "tool_calls": step_result.tool_calls_made,
+                        "execution_time": step_result.execution_time,
                     }
                 )
 
                 if self.agent.verbose:
-                    status = "success" if result.success else "failed"
+                    status = "success" if step_result.success else "failed"
                     self._printer.print(
                         content=(
                             f"[Execute] Step {todo.step_number} {status} "
-                            f"({result.execution_time:.1f}s, "
-                            f"{len(result.tool_calls_made)} tool calls)"
+                            f"({step_result.execution_time:.1f}s, "
+                            f"{len(step_result.tool_calls_made)} tool calls)"
                         ),
-                        color="green" if result.success else "red",
+                        color="green" if step_result.success else "red",
                     )
-                step_results.append((todo, result))
+                step_results.append((todo, step_result))
 
         # Observe each completed step sequentially (observation updates shared state)
         effort = self._get_reasoning_effort()
@@ -1431,8 +1440,8 @@ class AgentExecutor(Flow[AgentExecutorState], CrewAgentExecutorMixin):
             raise
 
     def _route_finish_with_todos(
-        self, default_route: str
-    ) -> Literal["native_finished", "agent_finished", "todo_satisfied"]:
+        self, default_route: _RouteT
+    ) -> _RouteT | Literal["todo_satisfied"]:
         """Helper to route finish events, checking for pending todos first.
 
         If there are pending todos, route to todo_satisfied instead of the
@@ -1448,7 +1457,7 @@ class AgentExecutor(Flow[AgentExecutorState], CrewAgentExecutorMixin):
             current_todo = self.state.todos.current_todo
             if current_todo:
                 return "todo_satisfied"
-        return default_route  # type: ignore[return-value]
+        return default_route
 
     @router(call_llm_and_parse)
     def route_by_answer_type(
@@ -2063,7 +2072,7 @@ class AgentExecutor(Flow[AgentExecutorState], CrewAgentExecutorMixin):
         elif not self.state.current_answer and self.state.messages:
             # For native tools, results are in the message history as 'tool' roles
             # We take the content of the most recent tool results
-            tool_results = []
+            tool_results: list[str] = []
             for msg in reversed(self.state.messages):
                 if msg.get("role") == "tool":
                     tool_results.insert(0, str(msg.get("content", "")))
@@ -3003,7 +3012,7 @@ class AgentExecutor(Flow[AgentExecutorState], CrewAgentExecutorMixin):
             Final answer after feedback.
         """
         provider = get_provider()
-        return provider.handle_feedback(formatted_answer, self)
+        return provider.handle_feedback(formatted_answer, cast("ExecutorContext", self))
 
     async def _ahandle_human_feedback(
         self, formatted_answer: AgentFinish
@@ -3017,7 +3026,9 @@ class AgentExecutor(Flow[AgentExecutorState], CrewAgentExecutorMixin):
             Final answer after feedback.
         """
         provider = get_provider()
-        return await provider.handle_feedback_async(formatted_answer, self)
+        return await provider.handle_feedback_async(
+            formatted_answer, cast("AsyncExecutorContext", self)
+        )
 
     def _is_training_mode(self) -> bool:
         """Check if training mode is active.

lib/crewai/src/crewai/experimental/evaluation/agent_evaluator.py

@@ -37,11 +37,11 @@ class ExecutionState:
     current_agent_id: str | None = None
     current_task_id: str | None = None
 
-    def __init__(self):
-        self.traces = {}
-        self.iteration = 1
-        self.iterations_results = {}
-        self.agent_evaluators = {}
+    def __init__(self) -> None:
+        self.traces: dict[str, Any] = {}
+        self.iteration: int = 1
+        self.iterations_results: dict[int, dict[str, list[AgentEvaluationResult]]] = {}
+        self.agent_evaluators: dict[str, Sequence[BaseEvaluator] | None] = {}
 
 
 class AgentEvaluator:
@@ -295,7 +295,7 @@ class AgentEvaluator:
 
     def emit_evaluation_started_event(
         self, agent_role: str, agent_id: str, task_id: str | None = None
-    ):
+    ) -> None:
         crewai_event_bus.emit(
             self,
             AgentEvaluationStartedEvent(
@@ -313,7 +313,7 @@ class AgentEvaluator:
         task_id: str | None = None,
         metric_category: MetricCategory | None = None,
         score: EvaluationScore | None = None,
-    ):
+    ) -> None:
         crewai_event_bus.emit(
             self,
             AgentEvaluationCompletedEvent(
@@ -328,7 +328,7 @@ class AgentEvaluator:
 
     def emit_evaluation_failed_event(
         self, agent_role: str, agent_id: str, error: str, task_id: str | None = None
-    ):
+    ) -> None:
         crewai_event_bus.emit(
             self,
             AgentEvaluationFailedEvent(
@@ -341,7 +341,9 @@ class AgentEvaluator:
         )
 
 
-def create_default_evaluator(agents: list[Agent] | list[BaseAgent], llm: None = None):
+def create_default_evaluator(
+    agents: list[Agent] | list[BaseAgent], llm: None = None
+) -> AgentEvaluator:
     from crewai.experimental.evaluation import (
         GoalAlignmentEvaluator,
         ParameterExtractionEvaluator,

lib/crewai/src/crewai/experimental/evaluation/base_evaluator.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Any
 from pydantic import BaseModel, Field
 
 from crewai.agents.agent_builder.base_agent import BaseAgent
-from crewai.llm import BaseLLM
+from crewai.llms.base_llm import BaseLLM
 from crewai.task import Task
 from crewai.utilities.llm_utils import create_llm
 
@@ -25,7 +25,7 @@ class MetricCategory(enum.Enum):
     PARAMETER_EXTRACTION = "parameter_extraction"
     TOOL_INVOCATION = "tool_invocation"
 
-    def title(self):
+    def title(self) -> str:
         return self.value.replace("_", " ").title()
 
 

lib/crewai/src/crewai/experimental/evaluation/evaluation_display.py

@@ -18,12 +18,12 @@ from crewai.utilities.types import LLMMessage
 
 
 class EvaluationDisplayFormatter:
-    def __init__(self):
+    def __init__(self) -> None:
         self.console_formatter = ConsoleFormatter()
 
     def display_evaluation_with_feedback(
         self, iterations_results: dict[int, dict[str, list[Any]]]
-    ):
+    ) -> None:
         if not iterations_results:
             self.console_formatter.print(
                 "[yellow]No evaluation results to display[/yellow]"
@@ -103,7 +103,7 @@ class EvaluationDisplayFormatter:
     def display_summary_results(
         self,
         iterations_results: dict[int, dict[str, list[AgentEvaluationResult]]],
-    ):
+    ) -> None:
         if not iterations_results:
             self.console_formatter.print(
                 "[yellow]No evaluation results to display[/yellow]"

lib/crewai/src/crewai/experimental/evaluation/evaluation_listener.py

@@ -1,6 +1,11 @@
+"""Event listener for collecting execution traces for evaluation."""
+
+from __future__ import annotations
+
 from collections.abc import Sequence
 from datetime import datetime
 from typing import Any
+from uuid import UUID
 
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.events.base_event_listener import BaseEventListener
@@ -30,47 +35,63 @@ class EvaluationTraceCallback(BaseEventListener):
     retrievals, and final output - all for use in agent evaluation.
     """
 
-    _instance = None
+    _instance: EvaluationTraceCallback | None = None
+    _initialized: bool = False
 
-    def __new__(cls):
+    def __new__(cls) -> EvaluationTraceCallback:
+        """Create or return the singleton instance."""
         if cls._instance is None:
             cls._instance = super().__new__(cls)
             cls._instance._initialized = False
         return cls._instance
 
-    def __init__(self):
-        if not hasattr(self, "_initialized") or not self._initialized:
+    def __init__(self) -> None:
+        """Initialize the evaluation trace callback."""
+        if not self._initialized:
             super().__init__()
-            self.traces = {}
-            self.current_agent_id = None
-            self.current_task_id = None
+            self.traces: dict[str, Any] = {}
+            self.current_agent_id: UUID | str | None = None
+            self.current_task_id: UUID | str | None = None
+            self.current_llm_call: dict[str, Any] = {}
             self._initialized = True
 
-    def setup_listeners(self, event_bus: CrewAIEventsBus):
+    def setup_listeners(self, event_bus: CrewAIEventsBus) -> None:
+        """Set up event listeners on the event bus.
+
+        Args:
+            event_bus: The event bus to register listeners on.
+        """
+
         @event_bus.on(AgentExecutionStartedEvent)
-        def on_agent_started(source, event: AgentExecutionStartedEvent):
+        def on_agent_started(source: Any, event: AgentExecutionStartedEvent) -> None:
             self.on_agent_start(event.agent, event.task)
 
         @event_bus.on(LiteAgentExecutionStartedEvent)
-        def on_lite_agent_started(source, event: LiteAgentExecutionStartedEvent):
+        def on_lite_agent_started(
+            source: Any, event: LiteAgentExecutionStartedEvent
+        ) -> None:
             self.on_lite_agent_start(event.agent_info)
 
         @event_bus.on(AgentExecutionCompletedEvent)
-        def on_agent_completed(source, event: AgentExecutionCompletedEvent):
+        def on_agent_completed(
+            source: Any, event: AgentExecutionCompletedEvent
+        ) -> None:
             self.on_agent_finish(event.agent, event.task, event.output)
 
         @event_bus.on(LiteAgentExecutionCompletedEvent)
-        def on_lite_agent_completed(source, event: LiteAgentExecutionCompletedEvent):
+        def on_lite_agent_completed(
+            source: Any, event: LiteAgentExecutionCompletedEvent
+        ) -> None:
             self.on_lite_agent_finish(event.output)
 
         @event_bus.on(ToolUsageFinishedEvent)
-        def on_tool_completed(source, event: ToolUsageFinishedEvent):
+        def on_tool_completed(source: Any, event: ToolUsageFinishedEvent) -> None:
             self.on_tool_use(
                 event.tool_name, event.tool_args, event.output, success=True
             )
 
         @event_bus.on(ToolUsageErrorEvent)
-        def on_tool_usage_error(source, event: ToolUsageErrorEvent):
+        def on_tool_usage_error(source: Any, event: ToolUsageErrorEvent) -> None:
             self.on_tool_use(
                 event.tool_name,
                 event.tool_args,
@@ -80,7 +101,9 @@ class EvaluationTraceCallback(BaseEventListener):
             )
 
         @event_bus.on(ToolExecutionErrorEvent)
-        def on_tool_execution_error(source, event: ToolExecutionErrorEvent):
+        def on_tool_execution_error(
+            source: Any, event: ToolExecutionErrorEvent
+        ) -> None:
             self.on_tool_use(
                 event.tool_name,
                 event.tool_args,
@@ -90,7 +113,9 @@ class EvaluationTraceCallback(BaseEventListener):
             )
 
         @event_bus.on(ToolSelectionErrorEvent)
-        def on_tool_selection_error(source, event: ToolSelectionErrorEvent):
+        def on_tool_selection_error(
+            source: Any, event: ToolSelectionErrorEvent
+        ) -> None:
             self.on_tool_use(
                 event.tool_name,
                 event.tool_args,
@@ -100,7 +125,9 @@ class EvaluationTraceCallback(BaseEventListener):
             )
 
         @event_bus.on(ToolValidateInputErrorEvent)
-        def on_tool_validate_input_error(source, event: ToolValidateInputErrorEvent):
+        def on_tool_validate_input_error(
+            source: Any, event: ToolValidateInputErrorEvent
+        ) -> None:
             self.on_tool_use(
                 event.tool_name,
                 event.tool_args,
@@ -110,14 +137,19 @@ class EvaluationTraceCallback(BaseEventListener):
             )
 
         @event_bus.on(LLMCallStartedEvent)
-        def on_llm_call_started(source, event: LLMCallStartedEvent):
+        def on_llm_call_started(source: Any, event: LLMCallStartedEvent) -> None:
             self.on_llm_call_start(event.messages, event.tools)
 
         @event_bus.on(LLMCallCompletedEvent)
-        def on_llm_call_completed(source, event: LLMCallCompletedEvent):
+        def on_llm_call_completed(source: Any, event: LLMCallCompletedEvent) -> None:
             self.on_llm_call_end(event.messages, event.response)
 
-    def on_lite_agent_start(self, agent_info: dict[str, Any]):
+    def on_lite_agent_start(self, agent_info: dict[str, Any]) -> None:
+        """Handle a lite agent execution start event.
+
+        Args:
+            agent_info: Dictionary containing agent information.
+        """
         self.current_agent_id = agent_info["id"]
         self.current_task_id = "lite_task"
 
@@ -132,10 +164,22 @@ class EvaluationTraceCallback(BaseEventListener):
             final_output=None,
         )
 
-    def _init_trace(self, trace_key: str, **kwargs: Any):
+    def _init_trace(self, trace_key: str, **kwargs: Any) -> None:
+        """Initialize a trace entry.
+
+        Args:
+            trace_key: The key to store the trace under.
+            **kwargs: Trace metadata to store.
+        """
         self.traces[trace_key] = kwargs
 
-    def on_agent_start(self, agent: BaseAgent, task: Task):
+    def on_agent_start(self, agent: BaseAgent, task: Task) -> None:
+        """Handle an agent execution start event.
+
+        Args:
+            agent: The agent that started execution.
+            task: The task being executed.
+        """
         self.current_agent_id = agent.id
         self.current_task_id = task.id
 
@@ -150,7 +194,14 @@ class EvaluationTraceCallback(BaseEventListener):
             final_output=None,
         )
 
-    def on_agent_finish(self, agent: BaseAgent, task: Task, output: Any):
+    def on_agent_finish(self, agent: BaseAgent, task: Task, output: Any) -> None:
+        """Handle an agent execution completion event.
+
+        Args:
+            agent: The agent that finished execution.
+            task: The task that was executed.
+            output: The agent's output.
+        """
         trace_key = f"{agent.id}_{task.id}"
         if trace_key in self.traces:
             self.traces[trace_key]["final_output"] = output
@@ -158,11 +209,17 @@ class EvaluationTraceCallback(BaseEventListener):
 
         self._reset_current()
 
-    def _reset_current(self):
+    def _reset_current(self) -> None:
+        """Reset the current agent and task tracking state."""
         self.current_agent_id = None
         self.current_task_id = None
 
-    def on_lite_agent_finish(self, output: Any):
+    def on_lite_agent_finish(self, output: Any) -> None:
+        """Handle a lite agent execution completion event.
+
+        Args:
+            output: The agent's output.
+        """
         trace_key = f"{self.current_agent_id}_lite_task"
         if trace_key in self.traces:
             self.traces[trace_key]["final_output"] = output
@@ -177,13 +234,22 @@ class EvaluationTraceCallback(BaseEventListener):
         result: Any,
         success: bool = True,
         error_type: str | None = None,
-    ):
+    ) -> None:
+        """Record a tool usage event in the current trace.
+
+        Args:
+            tool_name: Name of the tool used.
+            tool_args: Arguments passed to the tool.
+            result: The tool's output or error message.
+            success: Whether the tool call succeeded.
+            error_type: Type of error if the call failed.
+        """
         if not self.current_agent_id or not self.current_task_id:
             return
 
         trace_key = f"{self.current_agent_id}_{self.current_task_id}"
         if trace_key in self.traces:
-            tool_use = {
+            tool_use: dict[str, Any] = {
                 "tool": tool_name,
                 "args": tool_args,
                 "result": result,
@@ -191,7 +257,6 @@ class EvaluationTraceCallback(BaseEventListener):
                 "timestamp": datetime.now(),
             }
 
-            # Add error information if applicable
             if not success and error_type:
                 tool_use["error"] = True
                 tool_use["error_type"] = error_type
@@ -202,7 +267,13 @@ class EvaluationTraceCallback(BaseEventListener):
         self,
         messages: str | Sequence[dict[str, Any]] | None,
         tools: Sequence[dict[str, Any]] | None = None,
-    ):
+    ) -> None:
+        """Record an LLM call start event.
+
+        Args:
+            messages: The messages sent to the LLM.
+            tools: Tool definitions provided to the LLM.
+        """
         if not self.current_agent_id or not self.current_task_id:
             return
 
@@ -220,7 +291,13 @@ class EvaluationTraceCallback(BaseEventListener):
 
     def on_llm_call_end(
         self, messages: str | list[dict[str, Any]] | None, response: Any
-    ):
+    ) -> None:
+        """Record an LLM call completion event.
+
+        Args:
+            messages: The messages from the LLM call.
+            response: The LLM response object.
+        """
         if not self.current_agent_id or not self.current_task_id:
             return
 
@@ -229,17 +306,18 @@ class EvaluationTraceCallback(BaseEventListener):
             return
 
         total_tokens = 0
-        if hasattr(response, "usage") and hasattr(response.usage, "total_tokens"):
-            total_tokens = response.usage.total_tokens
+        usage = getattr(response, "usage", None)
+        if usage is not None:
+            total_tokens = getattr(usage, "total_tokens", 0)
 
         current_time = datetime.now()
-        start_time = None
-        if hasattr(self, "current_llm_call") and self.current_llm_call:
-            start_time = self.current_llm_call.get("start_time")
+        start_time = (
+            self.current_llm_call.get("start_time") if self.current_llm_call else None
+        )
 
         if not start_time:
             start_time = current_time
-        llm_call = {
+        llm_call: dict[str, Any] = {
             "messages": messages,
             "response": response,
             "start_time": start_time,
@@ -248,16 +326,28 @@ class EvaluationTraceCallback(BaseEventListener):
         }
 
         self.traces[trace_key]["llm_calls"].append(llm_call)
-
-        if hasattr(self, "current_llm_call"):
-            self.current_llm_call = {}
+        self.current_llm_call = {}
 
     def get_trace(self, agent_id: str, task_id: str) -> dict[str, Any] | None:
+        """Retrieve a trace by agent and task ID.
+
+        Args:
+            agent_id: The agent's identifier.
+            task_id: The task's identifier.
+
+        Returns:
+            The trace dictionary, or None if not found.
+        """
         trace_key = f"{agent_id}_{task_id}"
         return self.traces.get(trace_key)
 
 
 def create_evaluation_callbacks() -> EvaluationTraceCallback:
+    """Create and register an evaluation trace callback on the event bus.
+
+    Returns:
+        The configured EvaluationTraceCallback instance.
+    """
     from crewai.events.event_bus import crewai_event_bus
 
     callback = EvaluationTraceCallback()

lib/crewai/src/crewai/experimental/evaluation/experiment/result_display.py

@@ -8,10 +8,10 @@ from crewai.experimental.evaluation.experiment.result import ExperimentResults
 
 
 class ExperimentResultsDisplay:
-    def __init__(self):
+    def __init__(self) -> None:
         self.console = Console()
 
-    def summary(self, experiment_results: ExperimentResults):
+    def summary(self, experiment_results: ExperimentResults) -> None:
         total = len(experiment_results.results)
         passed = sum(1 for r in experiment_results.results if r.passed)
 
@@ -28,7 +28,9 @@ class ExperimentResultsDisplay:
 
         self.console.print(table)
 
-    def comparison_summary(self, comparison: dict[str, Any], baseline_timestamp: str):
+    def comparison_summary(
+        self, comparison: dict[str, Any], baseline_timestamp: str
+    ) -> None:
         self.console.print(
             Panel(
                 f"[bold]Comparison with baseline run from {baseline_timestamp}[/bold]",

lib/crewai/src/crewai/experimental/evaluation/experiment/runner.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any
 
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.experimental.evaluation import AgentEvaluator, create_default_evaluator
-from crewai.experimental.evaluation.evaluation_display import (
+from crewai.experimental.evaluation.base_evaluator import (
     AgentAggregatedEvaluationResult,
 )
 from crewai.experimental.evaluation.experiment.result import (

lib/crewai/src/crewai/experimental/evaluation/json_parser.py

@@ -7,7 +7,8 @@ from typing import Any
 
 def extract_json_from_llm_response(text: str) -> dict[str, Any]:
     try:
-        return json.loads(text)
+        result: dict[str, Any] = json.loads(text)
+        return result
     except json.JSONDecodeError:
         pass
 
@@ -24,7 +25,8 @@ def extract_json_from_llm_response(text: str) -> dict[str, Any]:
         matches = re.findall(pattern, text, re.IGNORECASE | re.DOTALL)
         for match in matches:
             try:
-                return json.loads(match.strip())
+                parsed: dict[str, Any] = json.loads(match.strip())
+                return parsed
             except json.JSONDecodeError:  # noqa: PERF203
                 continue
     raise ValueError("No valid JSON found in the response")

lib/crewai/src/crewai/experimental/evaluation/metrics/goal_metrics.py

@@ -68,7 +68,7 @@ Evaluate how well the agent's output aligns with the assigned task goal.
         ]
         if self.llm is None:
             raise ValueError("LLM must be initialized")
-        response = self.llm.call(prompt)  # type: ignore[arg-type]
+        response = self.llm.call(prompt)
 
         try:
             evaluation_data: dict[str, Any] = extract_json_from_llm_response(response)

lib/crewai/src/crewai/experimental/evaluation/metrics/reasoning_metrics.py

@@ -224,7 +224,9 @@ Identify any inefficient reasoning patterns and provide specific suggestions for
                 raw_response=response,
             )
 
-    def _detect_loops(self, llm_calls: list[dict]) -> tuple[bool, list[dict]]:
+    def _detect_loops(
+        self, llm_calls: list[dict[str, Any]]
+    ) -> tuple[bool, list[dict[str, Any]]]:
         loop_details = []
 
         messages = []
@@ -272,7 +274,9 @@ Identify any inefficient reasoning patterns and provide specific suggestions for
 
         return intersection / union if union > 0 else 0.0
 
-    def _analyze_reasoning_patterns(self, llm_calls: list[dict]) -> dict[str, Any]:
+    def _analyze_reasoning_patterns(
+        self, llm_calls: list[dict[str, Any]]
+    ) -> dict[str, Any]:
         call_lengths = []
         response_times = []
 
@@ -345,7 +349,7 @@ Identify any inefficient reasoning patterns and provide specific suggestions for
             max_possible_slope = max(values) - min(values)
             if max_possible_slope > 0:
                 normalized_slope = slope / max_possible_slope
-                return max(min(normalized_slope, 1.0), -1.0)
+                return float(max(min(normalized_slope, 1.0), -1.0))
             return 0.0
         except Exception:
             return 0.0
@@ -384,7 +388,7 @@ Identify any inefficient reasoning patterns and provide specific suggestions for
 
         return float(np.mean(indicators)) if indicators else 0.0
 
-    def _get_call_samples(self, llm_calls: list[dict]) -> str:
+    def _get_call_samples(self, llm_calls: list[dict[str, Any]]) -> str:
         samples = []
 
         if len(llm_calls) <= 6:

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

@@ -6,6 +6,7 @@ from crewai.flow.async_feedback import (
 )
 from crewai.flow.flow import Flow, and_, listen, or_, router, start
 from crewai.flow.flow_config import flow_config
+from crewai.flow.flow_serializer import flow_structure
 from crewai.flow.human_feedback import HumanFeedbackResult, human_feedback
 from crewai.flow.input_provider import InputProvider, InputResponse
 from crewai.flow.persistence import persist
@@ -29,6 +30,7 @@ __all__ = [
     "and_",
     "build_flow_structure",
     "flow_config",
+    "flow_structure",
     "human_feedback",
     "listen",
     "or_",

lib/crewai/src/crewai/flow/async_feedback/types.py

@@ -60,7 +60,7 @@ class PendingFeedbackContext:
     emit: list[str] | None = None
     default_outcome: str | None = None
     metadata: dict[str, Any] = field(default_factory=dict)
-    llm: str | None = None
+    llm: dict[str, Any] | str | None = None
     requested_at: datetime = field(default_factory=datetime.now)
 
     def to_dict(self) -> dict[str, Any]:

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

@@ -81,6 +81,7 @@ from crewai.flow.flow_wrappers import (
     SimpleFlowCondition,
     StartMethod,
 )
+from crewai.flow.input_provider import InputProvider
 from crewai.flow.persistence.base import FlowPersistence
 from crewai.flow.types import (
     FlowExecutionData,
@@ -99,6 +100,8 @@ from crewai.flow.utils import (
     is_flow_method_name,
     is_simple_flow_condition,
 )
+from crewai.memory.memory_scope import MemoryScope, MemorySlice
+from crewai.memory.unified_memory import Memory
 
 
 if TYPE_CHECKING:
@@ -110,6 +113,7 @@ if TYPE_CHECKING:
 
 from crewai.flow.visualization import build_flow_structure, render_interactive
 from crewai.types.streaming import CrewStreamingOutput, FlowStreamingOutput
+from crewai.utilities.env import get_env_context
 from crewai.utilities.streaming import (
     TaskInfo,
     create_async_chunk_generator,
@@ -500,7 +504,7 @@ class LockedListProxy(list, Generic[T]):  # type: ignore[type-arg]
 
     def index(
         self, value: T, start: SupportsIndex = 0, stop: SupportsIndex | None = None
-    ) -> int:  # type: ignore[override]
+    ) -> int:
         if stop is None:
             return self._list.index(value, start)
         return self._list.index(value, start, stop)
@@ -519,13 +523,13 @@ class LockedListProxy(list, Generic[T]):  # type: ignore[type-arg]
     def copy(self) -> list[T]:
         return self._list.copy()
 
-    def __add__(self, other: list[T]) -> list[T]:
+    def __add__(self, other: list[T]) -> list[T]:  # type: ignore[override]
         return self._list + other
 
     def __radd__(self, other: list[T]) -> list[T]:
         return other + self._list
 
-    def __iadd__(self, other: Iterable[T]) -> LockedListProxy[T]:
+    def __iadd__(self, other: Iterable[T]) -> LockedListProxy[T]:  # type: ignore[override]
         with self._lock:
             self._list += list(other)
         return self
@@ -629,13 +633,13 @@ class LockedDictProxy(dict, Generic[T]):  # type: ignore[type-arg]
     def copy(self) -> dict[str, T]:
         return self._dict.copy()
 
-    def __or__(self, other: dict[str, T]) -> dict[str, T]:
+    def __or__(self, other: dict[str, T]) -> dict[str, T]:  # type: ignore[override]
         return self._dict | other
 
-    def __ror__(self, other: dict[str, T]) -> dict[str, T]:
+    def __ror__(self, other: dict[str, T]) -> dict[str, T]:  # type: ignore[override]
         return other | self._dict
 
-    def __ior__(self, other: dict[str, T]) -> LockedDictProxy[T]:
+    def __ior__(self, other: dict[str, T]) -> LockedDictProxy[T]:  # type: ignore[override]
         with self._lock:
             self._dict |= other
         return self
@@ -821,10 +825,8 @@ class Flow(Generic[T], metaclass=FlowMeta):
     name: str | None = None
     tracing: bool | None = None
     stream: bool = False
-    memory: Any = (
-        None  # Memory | MemoryScope | MemorySlice | None; auto-created if not set
-    )
-    input_provider: Any = None  # InputProvider | None; per-flow override for self.ask()
+    memory: Memory | MemoryScope | MemorySlice | None = None
+    input_provider: InputProvider | None = None
 
     def __class_getitem__(cls: type[Flow[T]], item: type[T]) -> type[Flow[T]]:
         class _FlowGeneric(cls):  # type: ignore
@@ -903,9 +905,10 @@ class Flow(Generic[T], metaclass=FlowMeta):
         # Internal flows (RecallFlow, EncodingFlow) set _skip_auto_memory
         # to avoid creating a wasteful standalone Memory instance.
         if self.memory is None and not getattr(self, "_skip_auto_memory", False):
-            from crewai.memory.unified_memory import Memory
+            from crewai.memory.utils import sanitize_scope_name
 
-            self.memory = Memory()
+            flow_name = sanitize_scope_name(self.name or self.__class__.__name__)
+            self.memory = Memory(root_scope=f"/flow/{flow_name}")
 
         # Register all flow-related methods
         for method_name in dir(self):
@@ -950,10 +953,16 @@ class Flow(Generic[T], metaclass=FlowMeta):
 
         Raises:
             ValueError: If no memory is configured for this flow.
+            TypeError: If batch remember is attempted on a MemoryScope or MemorySlice.
         """
         if self.memory is None:
             raise ValueError("No memory configured for this flow")
         if isinstance(content, list):
+            if not isinstance(self.memory, Memory):
+                raise TypeError(
+                    "Batch remember requires a Memory instance, "
+                    f"got {type(self.memory).__name__}"
+                )
             return self.memory.remember_many(content, **kwargs)
         return self.memory.remember(content, **kwargs)
 
@@ -1309,7 +1318,25 @@ class Flow(Generic[T], metaclass=FlowMeta):
         context = self._pending_feedback_context
         emit = context.emit
         default_outcome = context.default_outcome
-        llm = context.llm
+
+        # Try to get the live LLM from the re-imported decorator first.
+        # This preserves the fully-configured object (credentials, safety_settings, etc.)
+        # for same-process resume. For cross-process resume, fall back to the
+        # serialized context.llm which is now a dict with full config (or a legacy string).
+        from crewai.flow.human_feedback import _deserialize_llm_from_context
+
+        llm = None
+        method = self._methods.get(FlowMethodName(context.method_name))
+        if method is not None:
+            live_llm = getattr(method, "_hf_llm", None)
+            if live_llm is not None:
+                from crewai.llms.base_llm import BaseLLM as BaseLLMClass
+
+                if isinstance(live_llm, BaseLLMClass):
+                    llm = live_llm
+
+        if llm is None:
+            llm = _deserialize_llm_from_context(context.llm)
 
         # Determine outcome
         collapsed_outcome: str | None = None
@@ -1770,6 +1797,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
         Returns:
             The final output from the flow or FlowStreamingOutput if streaming.
         """
+        get_env_context()
         if self.stream:
             result_holder: list[Any] = []
             current_task_info: TaskInfo = {
@@ -2723,7 +2751,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
 
     # ── User Input (self.ask) ────────────────────────────────────────
 
-    def _resolve_input_provider(self) -> Any:
+    def _resolve_input_provider(self) -> InputProvider:
         """Resolve the input provider using the priority chain.
 
         Resolution order:

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

@@ -6,7 +6,7 @@ customize Flow behavior at runtime.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 
 if TYPE_CHECKING:
@@ -32,17 +32,17 @@ class FlowConfig:
         self._input_provider: InputProvider | None = None
 
     @property
-    def hitl_provider(self) -> Any:
+    def hitl_provider(self) -> HumanFeedbackProvider | None:
         """Get the configured HITL provider."""
         return self._hitl_provider
 
     @hitl_provider.setter
-    def hitl_provider(self, provider: Any) -> None:
+    def hitl_provider(self, provider: HumanFeedbackProvider | None) -> None:
         """Set the HITL provider."""
         self._hitl_provider = provider
 
     @property
-    def input_provider(self) -> Any:
+    def input_provider(self) -> InputProvider | None:
         """Get the configured input provider for ``Flow.ask()``.
 
         Returns:
@@ -52,7 +52,7 @@ class FlowConfig:
         return self._input_provider
 
     @input_provider.setter
-    def input_provider(self, provider: Any) -> None:
+    def input_provider(self, provider: InputProvider | None) -> None:
         """Set the input provider for ``Flow.ask()``.
 
         Args:

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

@@ -0,0 +1,620 @@
+"""Flow structure serializer for introspecting Flow classes.
+
+This module provides the flow_structure() function that analyzes a Flow class
+and returns a JSON-serializable dictionary describing its graph structure.
+This is used by Studio UI to render a visual flow graph.
+
+Example:
+    >>> from crewai.flow import Flow, start, listen
+    >>> from crewai.flow.flow_serializer import flow_structure
+    >>>
+    >>> class MyFlow(Flow):
+    ...     @start()
+    ...     def begin(self):
+    ...         return "started"
+    ...
+    ...     @listen(begin)
+    ...     def process(self):
+    ...         return "done"
+    >>>
+    >>> structure = flow_structure(MyFlow)
+    >>> print(structure["name"])
+    'MyFlow'
+"""
+
+from __future__ import annotations
+
+import inspect
+import logging
+import re
+import textwrap
+from typing import Any, TypedDict, get_args, get_origin
+
+from pydantic import BaseModel
+from pydantic_core import PydanticUndefined
+
+from crewai.flow.flow_wrappers import (
+    FlowCondition,
+    FlowMethod,
+    ListenMethod,
+    RouterMethod,
+    StartMethod,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class MethodInfo(TypedDict, total=False):
+    """Information about a single flow method.
+
+    Attributes:
+        name: The method name.
+        type: Method type - start, listen, router, or start_router.
+        trigger_methods: List of method names that trigger this method.
+        condition_type: 'AND' or 'OR' for composite conditions, null otherwise.
+        router_paths: For routers, the possible route names returned.
+        has_human_feedback: Whether the method has @human_feedback decorator.
+        has_crew: Whether the method body references a Crew.
+    """
+
+    name: str
+    type: str
+    trigger_methods: list[str]
+    condition_type: str | None
+    router_paths: list[str]
+    has_human_feedback: bool
+    has_crew: bool
+
+
+class EdgeInfo(TypedDict, total=False):
+    """Information about an edge between flow methods.
+
+    Attributes:
+        from_method: Source method name.
+        to_method: Target method name.
+        edge_type: Type of edge - 'listen' or 'route'.
+        condition: Route name for router edges, null for listen edges.
+    """
+
+    from_method: str
+    to_method: str
+    edge_type: str
+    condition: str | None
+
+
+class StateFieldInfo(TypedDict, total=False):
+    """Information about a state field.
+
+    Attributes:
+        name: Field name.
+        type: Field type as string.
+        default: Default value if any.
+    """
+
+    name: str
+    type: str
+    default: Any
+
+
+class StateSchemaInfo(TypedDict, total=False):
+    """Information about the flow's state schema.
+
+    Attributes:
+        fields: List of field information.
+    """
+
+    fields: list[StateFieldInfo]
+
+
+class FlowStructureInfo(TypedDict, total=False):
+    """Complete flow structure information.
+
+    Attributes:
+        name: Flow class name.
+        description: Flow docstring if available.
+        methods: List of method information.
+        edges: List of edge information.
+        state_schema: State schema if typed, null otherwise.
+        inputs: Detected flow inputs if available.
+    """
+
+    name: str
+    description: str | None
+    methods: list[MethodInfo]
+    edges: list[EdgeInfo]
+    state_schema: StateSchemaInfo | None
+    inputs: list[str]
+
+
+def _get_method_type(
+    method_name: str,
+    method: Any,
+    start_methods: list[str],
+    routers: set[str],
+) -> str:
+    """Determine the type of a flow method.
+
+    Args:
+        method_name: Name of the method.
+        method: The method object.
+        start_methods: List of start method names.
+        routers: Set of router method names.
+
+    Returns:
+        One of: 'start', 'listen', 'router', or 'start_router'.
+    """
+    is_start = method_name in start_methods or getattr(
+        method, "__is_start_method__", False
+    )
+    is_router = method_name in routers or getattr(method, "__is_router__", False)
+
+    if is_start and is_router:
+        return "start_router"
+    if is_start:
+        return "start"
+    if is_router:
+        return "router"
+    return "listen"
+
+
+def _has_human_feedback(method: Any) -> bool:
+    """Check if a method has the @human_feedback decorator.
+
+    Args:
+        method: The method object to check.
+
+    Returns:
+        True if the method has __human_feedback_config__ attribute.
+    """
+    return hasattr(method, "__human_feedback_config__")
+
+
+def _detect_crew_reference(method: Any) -> bool:
+    """Detect if a method body references a Crew.
+
+    Checks for patterns like:
+    - .crew() method calls
+    - Crew( instantiation
+    - References to Crew class in type hints
+
+    Note:
+        This is a **best-effort heuristic for UI hints**, not a guarantee.
+        Uses inspect.getsource + regex which can false-positive on comments
+        or string literals, and may fail on dynamically generated methods
+        or lambdas. Do not rely on this for correctness-critical logic.
+
+    Args:
+        method: The method object to inspect.
+
+    Returns:
+        True if crew reference detected, False otherwise.
+    """
+    try:
+        # Get the underlying function from wrapper
+        func = method
+        if hasattr(method, "_meth"):
+            func = method._meth
+        elif hasattr(method, "__wrapped__"):
+            func = method.__wrapped__
+
+        source = inspect.getsource(func)
+        source = textwrap.dedent(source)
+
+        # Patterns that indicate Crew usage
+        crew_patterns = [
+            r"\.crew\(\)",  # .crew() method call
+            r"Crew\s*\(",  # Crew( instantiation
+            r":\s*Crew\b",  # Type hint with Crew
+            r"->.*Crew",  # Return type hint with Crew
+        ]
+
+        for pattern in crew_patterns:
+            if re.search(pattern, source):
+                return True
+
+        return False
+    except (OSError, TypeError):
+        # Can't get source code - assume no crew reference
+        return False
+
+
+def _extract_trigger_methods(method: Any) -> tuple[list[str], str | None]:
+    """Extract trigger methods and condition type from a method.
+
+    Args:
+        method: The method object to inspect.
+
+    Returns:
+        Tuple of (trigger_methods list, condition_type or None).
+    """
+    trigger_methods: list[str] = []
+    condition_type: str | None = None
+
+    # First try __trigger_methods__ (populated for simple conditions)
+    if hasattr(method, "__trigger_methods__") and method.__trigger_methods__:
+        trigger_methods = [str(m) for m in method.__trigger_methods__]
+
+    # For complex conditions (or_/and_ combinators), extract from __trigger_condition__
+    if (
+        not trigger_methods
+        and hasattr(method, "__trigger_condition__")
+        and method.__trigger_condition__
+    ):
+        trigger_condition = method.__trigger_condition__
+        trigger_methods = _extract_all_methods_from_condition(trigger_condition)
+
+    if hasattr(method, "__condition_type__") and method.__condition_type__:
+        condition_type = str(method.__condition_type__)
+
+    return trigger_methods, condition_type
+
+
+def _extract_router_paths(
+    method: Any, router_paths_registry: dict[str, list[str]]
+) -> list[str]:
+    """Extract router paths for a router method.
+
+    Args:
+        method: The method object.
+        router_paths_registry: The class-level _router_paths dict.
+
+    Returns:
+        List of possible route names.
+    """
+    method_name = getattr(method, "__name__", "")
+
+    # First check if there are __router_paths__ on the method itself
+    if hasattr(method, "__router_paths__") and method.__router_paths__:
+        return [str(p) for p in method.__router_paths__]
+
+    # Then check the class-level registry
+    if method_name in router_paths_registry:
+        return [str(p) for p in router_paths_registry[method_name]]
+
+    return []
+
+
+def _extract_all_methods_from_condition(
+    condition: str | FlowCondition | dict[str, Any] | list[Any],
+) -> list[str]:
+    """Extract all method names from a condition tree recursively.
+
+    Args:
+        condition: Can be a string, FlowCondition tuple, dict, or list.
+
+    Returns:
+        List of all method names found in the condition.
+    """
+    if isinstance(condition, str):
+        return [condition]
+    if isinstance(condition, tuple) and len(condition) == 2:
+        # FlowCondition: (condition_type, methods_list)
+        _, methods = condition
+        if isinstance(methods, list):
+            result: list[str] = []
+            for m in methods:
+                result.extend(_extract_all_methods_from_condition(m))
+            return result
+        return []
+    if isinstance(condition, dict):
+        conditions_list = condition.get("conditions", [])
+        dict_methods: list[str] = []
+        for sub_cond in conditions_list:
+            dict_methods.extend(_extract_all_methods_from_condition(sub_cond))
+        return dict_methods
+    if isinstance(condition, list):
+        list_methods: list[str] = []
+        for item in condition:
+            list_methods.extend(_extract_all_methods_from_condition(item))
+        return list_methods
+    return []
+
+
+def _generate_edges(
+    listeners: dict[str, tuple[str, list[str]] | FlowCondition],
+    routers: set[str],
+    router_paths: dict[str, list[str]],
+    all_methods: set[str],
+) -> list[EdgeInfo]:
+    """Generate edges from listeners and routers.
+
+    Args:
+        listeners: Map of listener_name -> (condition_type, trigger_methods) or FlowCondition.
+        routers: Set of router method names.
+        router_paths: Map of router_name -> possible return values.
+        all_methods: Set of all method names in the flow.
+
+    Returns:
+        List of EdgeInfo dictionaries.
+    """
+    edges: list[EdgeInfo] = []
+
+    # Generate edges from listeners (listen edges)
+    for listener_name, condition_data in listeners.items():
+        trigger_methods: list[str] = []
+
+        if isinstance(condition_data, tuple) and len(condition_data) == 2:
+            _condition_type, methods = condition_data
+            trigger_methods = [str(m) for m in methods]
+        elif isinstance(condition_data, dict):
+            trigger_methods = _extract_all_methods_from_condition(condition_data)
+
+        # Create edges from each trigger to the listener
+        edges.extend(
+            EdgeInfo(
+                from_method=trigger,
+                to_method=listener_name,
+                edge_type="listen",
+                condition=None,
+            )
+            for trigger in trigger_methods
+            if trigger in all_methods
+        )
+
+    # Generate edges from routers (route edges)
+    for router_name, paths in router_paths.items():
+        for path in paths:
+            # Find listeners that listen to this path
+            for listener_name, condition_data in listeners.items():
+                path_triggers: list[str] = []
+
+                if isinstance(condition_data, tuple) and len(condition_data) == 2:
+                    _, methods = condition_data
+                    path_triggers = [str(m) for m in methods]
+                elif isinstance(condition_data, dict):
+                    path_triggers = _extract_all_methods_from_condition(condition_data)
+
+                if str(path) in path_triggers:
+                    edges.append(
+                        EdgeInfo(
+                            from_method=router_name,
+                            to_method=listener_name,
+                            edge_type="route",
+                            condition=str(path),
+                        )
+                    )
+
+    return edges
+
+
+def _extract_state_schema(flow_class: type) -> StateSchemaInfo | None:
+    """Extract state schema from a Flow class.
+
+    Checks for:
+    - Generic type parameter (Flow[MyState])
+    - initial_state class attribute
+
+    Args:
+        flow_class: The Flow class to inspect.
+
+    Returns:
+        StateSchemaInfo if a Pydantic model state is detected, None otherwise.
+    """
+    state_type: type | None = None
+
+    # Check for _initial_state_t set by __class_getitem__
+    if hasattr(flow_class, "_initial_state_t"):
+        state_type = flow_class._initial_state_t
+
+    # Check initial_state class attribute
+    if state_type is None and hasattr(flow_class, "initial_state"):
+        initial_state = flow_class.initial_state
+        if isinstance(initial_state, type) and issubclass(initial_state, BaseModel):
+            state_type = initial_state
+        elif isinstance(initial_state, BaseModel):
+            state_type = type(initial_state)
+
+    # Check __orig_bases__ for generic parameters
+    if state_type is None and hasattr(flow_class, "__orig_bases__"):
+        for base in flow_class.__orig_bases__:
+            origin = get_origin(base)
+            if origin is not None:
+                args = get_args(base)
+                if args:
+                    candidate = args[0]
+                    if isinstance(candidate, type) and issubclass(candidate, BaseModel):
+                        state_type = candidate
+                        break
+
+    if state_type is None or not issubclass(state_type, BaseModel):
+        return None
+
+    # Extract fields from the Pydantic model
+    fields: list[StateFieldInfo] = []
+    try:
+        model_fields = state_type.model_fields
+        for field_name, field_info in model_fields.items():
+            field_type_str = "Any"
+            if field_info.annotation is not None:
+                field_type_str = str(field_info.annotation)
+                # Clean up the type string
+                field_type_str = field_type_str.replace("typing.", "")
+                field_type_str = field_type_str.replace("<class '", "").replace(
+                    "'>", ""
+                )
+
+            default_value = None
+            if (
+                field_info.default is not PydanticUndefined
+                and field_info.default is not None
+                and not callable(field_info.default)
+            ):
+                try:
+                    # Try to serialize the default value
+                    default_value = field_info.default
+                except Exception:
+                    default_value = str(field_info.default)
+
+            fields.append(
+                StateFieldInfo(
+                    name=field_name,
+                    type=field_type_str,
+                    default=default_value,
+                )
+            )
+    except Exception:
+        logger.debug(
+            "Failed to extract state schema fields for %s", flow_class.__name__
+        )
+
+    return StateSchemaInfo(fields=fields) if fields else None
+
+
+def _detect_flow_inputs(flow_class: type) -> list[str]:
+    """Detect flow input parameters.
+
+    Inspects the __init__ signature for custom parameters beyond standard Flow params.
+
+    Args:
+        flow_class: The Flow class to inspect.
+
+    Returns:
+        List of detected input names.
+    """
+    inputs: list[str] = []
+
+    # Check for inputs in __init__ signature beyond standard Flow params
+    try:
+        init_method = flow_class.__init__  # type: ignore[misc]
+        init_sig = inspect.signature(init_method)
+        standard_params = {
+            "self",
+            "persistence",
+            "tracing",
+            "suppress_flow_events",
+            "max_method_calls",
+            "kwargs",
+        }
+        inputs.extend(
+            param_name
+            for param_name in init_sig.parameters
+            if param_name not in standard_params and not param_name.startswith("_")
+        )
+    except Exception:
+        logger.debug(
+            "Failed to detect inputs from __init__ for %s", flow_class.__name__
+        )
+
+    return inputs
+
+
+def flow_structure(flow_class: type) -> FlowStructureInfo:
+    """Introspect a Flow class and return its structure as a JSON-serializable dict.
+
+    This function analyzes a Flow CLASS (not instance) and returns complete
+    information about its graph structure including methods, edges, and state.
+
+    Args:
+        flow_class: A Flow class (not an instance) to introspect.
+
+    Returns:
+        FlowStructureInfo dictionary containing:
+        - name: Flow class name
+        - description: Docstring if available
+        - methods: List of method info dicts
+        - edges: List of edge info dicts
+        - state_schema: State schema if typed, None otherwise
+        - inputs: Detected input names
+
+    Raises:
+        TypeError: If flow_class is not a class.
+
+    Example:
+        >>> structure = flow_structure(MyFlow)
+        >>> print(structure["name"])
+        'MyFlow'
+        >>> for method in structure["methods"]:
+        ...     print(method["name"], method["type"])
+    """
+    if not isinstance(flow_class, type):
+        raise TypeError(
+            f"flow_structure requires a Flow class, not an instance. "
+            f"Got {type(flow_class).__name__}"
+        )
+
+    # Get class-level metadata set by FlowMeta
+    start_methods: list[str] = getattr(flow_class, "_start_methods", [])
+    listeners: dict[str, Any] = getattr(flow_class, "_listeners", {})
+    routers: set[str] = getattr(flow_class, "_routers", set())
+    router_paths_registry: dict[str, list[str]] = getattr(
+        flow_class, "_router_paths", {}
+    )
+
+    # Collect all flow methods
+    methods: list[MethodInfo] = []
+    all_method_names: set[str] = set()
+
+    for attr_name in dir(flow_class):
+        if attr_name.startswith("_"):
+            continue
+
+        try:
+            attr = getattr(flow_class, attr_name)
+        except AttributeError:
+            continue
+
+        # Check if it's a flow method
+        is_flow_method = (
+            isinstance(attr, (FlowMethod, StartMethod, ListenMethod, RouterMethod))
+            or hasattr(attr, "__is_flow_method__")
+            or hasattr(attr, "__is_start_method__")
+            or hasattr(attr, "__trigger_methods__")
+            or hasattr(attr, "__is_router__")
+        )
+
+        if not is_flow_method:
+            continue
+
+        all_method_names.add(attr_name)
+
+        # Get method type
+        method_type = _get_method_type(attr_name, attr, start_methods, routers)
+
+        # Get trigger methods and condition type
+        trigger_methods, condition_type = _extract_trigger_methods(attr)
+
+        # Get router paths if applicable
+        router_paths_list: list[str] = []
+        if method_type in ("router", "start_router"):
+            router_paths_list = _extract_router_paths(attr, router_paths_registry)
+
+        # Check for human feedback
+        has_hf = _has_human_feedback(attr)
+
+        # Check for crew reference
+        has_crew = _detect_crew_reference(attr)
+
+        method_info = MethodInfo(
+            name=attr_name,
+            type=method_type,
+            trigger_methods=trigger_methods,
+            condition_type=condition_type,
+            router_paths=router_paths_list,
+            has_human_feedback=has_hf,
+            has_crew=has_crew,
+        )
+        methods.append(method_info)
+
+    # Generate edges
+    edges = _generate_edges(listeners, routers, router_paths_registry, all_method_names)
+
+    # Extract state schema
+    state_schema = _extract_state_schema(flow_class)
+
+    # Detect inputs
+    inputs = _detect_flow_inputs(flow_class)
+
+    # Get flow description from docstring
+    description: str | None = None
+    if flow_class.__doc__:
+        description = flow_class.__doc__.strip()
+
+    return FlowStructureInfo(
+        name=flow_class.__name__,
+        description=description,
+        methods=methods,
+        edges=edges,
+        state_schema=state_schema,
+        inputs=inputs,
+    )

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

@@ -75,6 +75,7 @@ class FlowMethod(Generic[P, R]):
             "__is_router__",
             "__router_paths__",
             "__human_feedback_config__",
+            "_hf_llm",  # Live LLM object for HITL resume
         ]:
             if hasattr(meth, attr):
                 setattr(self, attr, getattr(meth, attr))

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

@@ -76,22 +76,51 @@ if TYPE_CHECKING:
 F = TypeVar("F", bound=Callable[..., Any])
 
 
-def _serialize_llm_for_context(llm: Any) -> str | None:
-    """Serialize a BaseLLM object to a model string with provider prefix.
+def _serialize_llm_for_context(llm: Any) -> dict[str, Any] | str | None:
+    """Serialize a BaseLLM object to a dict preserving full config.
 
-    When persisting the LLM for HITL resume, we need to store enough info
-    to reconstruct a working LLM on the resume worker. Just storing the bare
-    model name (e.g. "gemini-3-flash-preview") causes provider inference to
-    fail — it defaults to OpenAI. Including the provider prefix (e.g.
-    "gemini/gemini-3-flash-preview") allows LLM() to correctly route.
+    Delegates to ``llm.to_config_dict()`` when available (BaseLLM and
+    subclasses). Falls back to extracting the model string with provider
+    prefix for unknown LLM types.
     """
+    to_config: Callable[[], dict[str, Any]] | None = getattr(
+        llm, "to_config_dict", None
+    )
+    if to_config is not None:
+        return to_config()
+
+    # Fallback for non-BaseLLM objects: just extract model + provider prefix
     model = getattr(llm, "model", None)
     if not model:
         return None
     provider = getattr(llm, "provider", None)
-    if provider and "/" not in model:
-        return f"{provider}/{model}"
-    return model
+    return f"{provider}/{model}" if provider and "/" not in model else model
+
+
+def _deserialize_llm_from_context(
+    llm_data: dict[str, Any] | str | None,
+) -> BaseLLM | None:
+    """Reconstruct an LLM instance from serialized context data.
+
+    Handles both the new dict format (with full config) and the legacy
+    string format (model name only) for backward compatibility.
+
+    Returns a BaseLLM instance, or None if llm_data is None.
+    """
+    if llm_data is None:
+        return None
+
+    from crewai.llm import LLM
+
+    if isinstance(llm_data, str):
+        return LLM(model=llm_data)
+
+    if isinstance(llm_data, dict):
+        model = llm_data.pop("model", None)
+        if not model:
+            return None
+        return LLM(model=model, **llm_data)
+    return None
 
 
 @dataclass
@@ -345,8 +374,13 @@ def human_feedback(
         ) -> Any:
             """Recall past HITL lessons and use LLM to pre-review the output."""
             try:
+                from crewai.memory.unified_memory import Memory
+
+                mem = flow_instance.memory
+                if not isinstance(mem, Memory):
+                    return method_output
                 query = f"human feedback lessons for {func.__name__}: {method_output!s}"
-                matches = flow_instance.memory.recall(query, source=learn_source)
+                matches = mem.recall(query, source=learn_source)
                 if not matches:
                     return method_output
 
@@ -378,6 +412,11 @@ def human_feedback(
         ) -> None:
             """Extract generalizable lessons from output + feedback, store in memory."""
             try:
+                from crewai.memory.unified_memory import Memory
+
+                mem = flow_instance.memory
+                if not isinstance(mem, Memory):
+                    return
                 llm_inst = _resolve_llm_instance()
                 prompt = _get_hitl_prompt("hitl_distill_user").format(
                     method_name=func.__name__,
@@ -409,7 +448,7 @@ def human_feedback(
                         ]
 
                 if lessons:
-                    flow_instance.memory.remember_many(lessons, source=learn_source)
+                    mem.remember_many(lessons, source=learn_source)
             except Exception:  # noqa: S110
                 pass  # non-critical: don't fail the flow because lesson storage failed
 
@@ -572,6 +611,14 @@ def human_feedback(
             wrapper.__is_router__ = True
             wrapper.__router_paths__ = list(emit)
 
+        # Stash the live LLM object for HITL resume to retrieve.
+        # When a flow pauses for human feedback and later resumes (possibly in a
+        # different process), the serialized context only contains a model string.
+        # By storing the original LLM on the wrapper, resume_async can retrieve
+        # the fully-configured LLM (with credentials, project, safety_settings, etc.)
+        # instead of creating a bare LLM from just the model string.
+        wrapper._hf_llm = llm
+
         return wrapper  # type: ignore[no-any-return]
 
     return decorator

lib/crewai/src/crewai/hooks/decorators.py

@@ -122,7 +122,7 @@ def before_llm_call(
     """
     from crewai.hooks.llm_hooks import register_before_llm_call_hook
 
-    return _create_hook_decorator(  # type: ignore[return-value]
+    return _create_hook_decorator(  # type: ignore[no-any-return]
         hook_type="llm",
         register_function=register_before_llm_call_hook,
         marker_attribute="is_before_llm_call_hook",
@@ -176,7 +176,7 @@ def after_llm_call(
     """
     from crewai.hooks.llm_hooks import register_after_llm_call_hook
 
-    return _create_hook_decorator(  # type: ignore[return-value]
+    return _create_hook_decorator(  # type: ignore[no-any-return]
         hook_type="llm",
         register_function=register_after_llm_call_hook,
         marker_attribute="is_after_llm_call_hook",
@@ -237,7 +237,7 @@ def before_tool_call(
     """
     from crewai.hooks.tool_hooks import register_before_tool_call_hook
 
-    return _create_hook_decorator(  # type: ignore[return-value]
+    return _create_hook_decorator(  # type: ignore[no-any-return]
         hook_type="tool",
         register_function=register_before_tool_call_hook,
         marker_attribute="is_before_tool_call_hook",
@@ -293,7 +293,7 @@ def after_tool_call(
     """
     from crewai.hooks.tool_hooks import register_after_tool_call_hook
 
-    return _create_hook_decorator(  # type: ignore[return-value]
+    return _create_hook_decorator(  # type: ignore[no-any-return]
         hook_type="tool",
         register_function=register_after_tool_call_hook,
         marker_attribute="is_after_tool_call_hook",

lib/crewai/src/crewai/knowledge/source/base_knowledge_source.py

@@ -13,7 +13,7 @@ class BaseKnowledgeSource(BaseModel, ABC):
     chunk_size: int = 4000
     chunk_overlap: int = 200
     chunks: list[str] = Field(default_factory=list)
-    chunk_embeddings: list[np.ndarray] = Field(default_factory=list)
+    chunk_embeddings: list[np.ndarray[Any, np.dtype[Any]]] = Field(default_factory=list)
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
     storage: KnowledgeStorage | None = Field(default=None)
@@ -28,7 +28,7 @@ class BaseKnowledgeSource(BaseModel, ABC):
     def add(self) -> None:
         """Process content, chunk it, compute embeddings, and save them."""
 
-    def get_embeddings(self) -> list[np.ndarray]:
+    def get_embeddings(self) -> list[np.ndarray[Any, np.dtype[Any]]]:
         """Return the list of embeddings for the chunks."""
         return self.chunk_embeddings
 

lib/crewai/src/crewai/llm.py

@@ -62,18 +62,6 @@ except ImportError:
 
 
 if TYPE_CHECKING:
-    from litellm.exceptions import ContextWindowExceededError
-    from litellm.litellm_core_utils.get_supported_openai_params import (
-        get_supported_openai_params,
-    )
-    from litellm.types.utils import (
-        ChatCompletionDeltaToolCall,
-        Choices,
-        Function,
-        ModelResponse,
-    )
-    from litellm.utils import supports_response_schema
-
     from crewai.agent.core import Agent
     from crewai.llms.hooks.base import BaseInterceptor
     from crewai.llms.providers.anthropic.completion import AnthropicThinkingConfig
@@ -83,8 +71,6 @@ if TYPE_CHECKING:
 
 try:
     import litellm
-    from litellm.exceptions import ContextWindowExceededError
-    from litellm.integrations.custom_logger import CustomLogger
     from litellm.litellm_core_utils.get_supported_openai_params import (
         get_supported_openai_params,
     )
@@ -99,15 +85,13 @@ try:
     LITELLM_AVAILABLE = True
 except ImportError:
     LITELLM_AVAILABLE = False
-    litellm = None  # type: ignore
-    Choices = None  # type: ignore
-    ContextWindowExceededError = Exception  # type: ignore
-    get_supported_openai_params = None  # type: ignore
-    ChatCompletionDeltaToolCall = None  # type: ignore
-    Function = None  # type: ignore
-    ModelResponse = None  # type: ignore
-    supports_response_schema = None  # type: ignore
-    CustomLogger = None  # type: ignore
+    litellm = None  # type: ignore[assignment]
+    Choices = None  # type: ignore[assignment, misc]
+    get_supported_openai_params = None  # type: ignore[assignment]
+    ChatCompletionDeltaToolCall = None  # type: ignore[assignment, misc]
+    Function = None  # type: ignore[assignment, misc]
+    ModelResponse = None  # type: ignore[assignment, misc]
+    supports_response_schema = None  # type: ignore[assignment]
 
 
 load_dotenv()
@@ -325,6 +309,14 @@ SUPPORTED_NATIVE_PROVIDERS: Final[list[str]] = [
     "gemini",
     "bedrock",
     "aws",
+    # OpenAI-compatible providers
+    "openrouter",
+    "deepseek",
+    "ollama",
+    "ollama_chat",
+    "hosted_vllm",
+    "cerebras",
+    "dashscope",
 ]
 
 
@@ -384,6 +376,14 @@ class LLM(BaseLLM):
                 "gemini": "gemini",
                 "bedrock": "bedrock",
                 "aws": "bedrock",
+                # OpenAI-compatible providers
+                "openrouter": "openrouter",
+                "deepseek": "deepseek",
+                "ollama": "ollama",
+                "ollama_chat": "ollama_chat",
+                "hosted_vllm": "hosted_vllm",
+                "cerebras": "cerebras",
+                "dashscope": "dashscope",
             }
 
             canonical_provider = provider_mapping.get(prefix.lower())
@@ -483,6 +483,29 @@ class LLM(BaseLLM):
                 for prefix in ["gpt-", "gpt-35-", "o1", "o3", "o4", "azure-"]
             )
 
+        # OpenAI-compatible providers - accept any model name since these
+        # providers host many different models with varied naming conventions
+        if provider == "deepseek":
+            return model_lower.startswith("deepseek")
+
+        if provider == "ollama" or provider == "ollama_chat":
+            # Ollama accepts any local model name
+            return True
+
+        if provider == "hosted_vllm":
+            # vLLM serves any model
+            return True
+
+        if provider == "cerebras":
+            return True
+
+        if provider == "dashscope":
+            return model_lower.startswith("qwen")
+
+        if provider == "openrouter":
+            # OpenRouter uses org/model format but accepts anything
+            return True
+
         return False
 
     @classmethod
@@ -582,6 +605,23 @@ class LLM(BaseLLM):
 
             return BedrockCompletion
 
+        # OpenAI-compatible providers
+        openai_compatible_providers = {
+            "openrouter",
+            "deepseek",
+            "ollama",
+            "ollama_chat",
+            "hosted_vllm",
+            "cerebras",
+            "dashscope",
+        }
+        if provider in openai_compatible_providers:
+            from crewai.llms.providers.openai_compatible.completion import (
+                OpenAICompatibleCompletion,
+            )
+
+            return OpenAICompatibleCompletion
+
         return None
 
     def __init__(
@@ -1009,12 +1049,15 @@ class LLM(BaseLLM):
             )
             return full_response
 
-        except ContextWindowExceededError as e:
-            # Catch context window errors from litellm and convert them to our own exception type.
-            # This exception is handled by CrewAgentExecutor._invoke_loop() which can then
-            # decide whether to summarize the content or abort based on the respect_context_window flag.
-            raise LLMContextLengthExceededError(str(e)) from e
+        except LLMContextLengthExceededError:
+            # Re-raise our own context length error
+            raise
         except Exception as e:
+            # Check if this is a context window error and convert to our exception type
+            error_msg = str(e)
+            if LLMContextLengthExceededError._is_context_limit_error(error_msg):
+                raise LLMContextLengthExceededError(error_msg) from e
+
             logging.error(f"Error in streaming response: {e!s}")
             if full_response.strip():
                 logging.warning(f"Returning partial response despite error: {e!s}")
@@ -1195,10 +1238,15 @@ class LLM(BaseLLM):
                 usage_info = response.usage
                 self._track_token_usage_internal(usage_info)
 
-        except ContextWindowExceededError as e:
-            # Convert litellm's context window error to our own exception type
-            # for consistent handling in the rest of the codebase
-            raise LLMContextLengthExceededError(str(e)) from e
+        except LLMContextLengthExceededError:
+            # Re-raise our own context length error
+            raise
+        except Exception as e:
+            # Check if this is a context window error and convert to our exception type
+            error_msg = str(e)
+            if LLMContextLengthExceededError._is_context_limit_error(error_msg):
+                raise LLMContextLengthExceededError(error_msg) from e
+            raise
 
         # --- 2) Handle structured output response (when response_model is provided)
         if response_model is not None:
@@ -1330,8 +1378,15 @@ class LLM(BaseLLM):
                 usage_info = response.usage
                 self._track_token_usage_internal(usage_info)
 
-        except ContextWindowExceededError as e:
-            raise LLMContextLengthExceededError(str(e)) from e
+        except LLMContextLengthExceededError:
+            # Re-raise our own context length error
+            raise
+        except Exception as e:
+            # Check if this is a context window error and convert to our exception type
+            error_msg = str(e)
+            if LLMContextLengthExceededError._is_context_limit_error(error_msg):
+                raise LLMContextLengthExceededError(error_msg) from e
+            raise
 
         if response_model is not None:
             if isinstance(response, BaseModel):
@@ -1548,9 +1603,15 @@ class LLM(BaseLLM):
             )
             return full_response
 
-        except ContextWindowExceededError as e:
-            raise LLMContextLengthExceededError(str(e)) from e
-        except Exception:
+        except LLMContextLengthExceededError:
+            # Re-raise our own context length error
+            raise
+        except Exception as e:
+            # Check if this is a context window error and convert to our exception type
+            error_msg = str(e)
+            if LLMContextLengthExceededError._is_context_limit_error(error_msg):
+                raise LLMContextLengthExceededError(error_msg) from e
+
             if chunk_count == 0:
                 raise
             if full_response:
@@ -1984,7 +2045,16 @@ class LLM(BaseLLM):
         Returns:
             Messages with files formatted into content blocks.
         """
-        if not HAS_CREWAI_FILES or not self.supports_multimodal():
+        if not HAS_CREWAI_FILES:
+            return messages
+
+        if not self.supports_multimodal():
+            if any(msg.get("files") for msg in messages):
+                raise ValueError(
+                    f"Model '{self.model}' does not support multimodal input, "
+                    "but files were provided via 'input_files'. "
+                    "Use a vision-capable model or remove the file inputs."
+                )
             return messages
 
         provider = getattr(self, "provider", None) or self.model
@@ -2026,7 +2096,16 @@ class LLM(BaseLLM):
         Returns:
             Messages with files formatted into content blocks.
         """
-        if not HAS_CREWAI_FILES or not self.supports_multimodal():
+        if not HAS_CREWAI_FILES:
+            return messages
+
+        if not self.supports_multimodal():
+            if any(msg.get("files") for msg in messages):
+                raise ValueError(
+                    f"Model '{self.model}' does not support multimodal input, "
+                    "but files were provided via 'input_files'. "
+                    "Use a vision-capable model or remove the file inputs."
+                )
             return messages
 
         provider = getattr(self, "provider", None) or self.model
@@ -2139,7 +2218,15 @@ class LLM(BaseLLM):
           - E.g., "openrouter/deepseek/deepseek-chat" yields "openrouter"
           - "gemini/gemini-1.5-pro" yields "gemini"
           - If no slash is present, "openai" is assumed.
+
+        Note: This validation only applies to the litellm fallback path.
+        Native providers have their own validation.
         """
+        if not LITELLM_AVAILABLE or supports_response_schema is None:
+            # When litellm is not available, skip validation
+            # (this path should only be reached for litellm fallback models)
+            return
+
         provider = self._get_custom_llm_provider()
         if self.response_format is not None and not supports_response_schema(
             model=self.model,
@@ -2151,6 +2238,16 @@ class LLM(BaseLLM):
             )
 
     def supports_function_calling(self) -> bool:
+        """Check if the model supports function calling.
+
+        Note: This method is only used by the litellm fallback path.
+        Native providers override this method with their own implementation.
+        """
+        if not LITELLM_AVAILABLE:
+            # When litellm is not available, assume function calling is supported
+            # (all modern models support it)
+            return True
+
         try:
             provider = self._get_custom_llm_provider()
             return litellm.utils.supports_function_calling(
@@ -2158,15 +2255,24 @@ class LLM(BaseLLM):
             )
         except Exception as e:
             logging.error(f"Failed to check function calling support: {e!s}")
-            return False
+            return True  # Default to True for modern models
 
     def supports_stop_words(self) -> bool:
+        """Check if the model supports stop words.
+
+        Note: This method is only used by the litellm fallback path.
+        Native providers override this method with their own implementation.
+        """
+        if not LITELLM_AVAILABLE or get_supported_openai_params is None:
+            # When litellm is not available, assume stop words are supported
+            return True
+
         try:
             params = get_supported_openai_params(model=self.model)
             return params is not None and "stop" in params
         except Exception as e:
             logging.error(f"Failed to get supported params: {e!s}")
-            return False
+            return True  # Default to True
 
     def get_context_window_size(self) -> int:
         """
@@ -2202,7 +2308,15 @@ class LLM(BaseLLM):
         """
         Attempt to keep a single set of callbacks in litellm by removing old
         duplicates and adding new ones.
+
+        Note: This only affects the litellm fallback path. Native providers
+        don't use litellm callbacks - they emit events via base_llm.py.
         """
+        if not LITELLM_AVAILABLE:
+            # When litellm is not available, callbacks are still stored
+            # but not registered with litellm globals
+            return
+
         with suppress_warnings():
             callback_types = [type(callback) for callback in callbacks]
             for callback in litellm.success_callback[:]:
@@ -2227,6 +2341,9 @@ class LLM(BaseLLM):
         If the environment variables are not set or are empty, the corresponding callback lists
         will be set to empty lists.
 
+        Note: This only affects the litellm fallback path. Native providers
+        don't use litellm callbacks - they emit events via base_llm.py.
+
         Examples:
             LITELLM_SUCCESS_CALLBACKS="langfuse,langsmith"
             LITELLM_FAILURE_CALLBACKS="langfuse"
@@ -2234,9 +2351,13 @@ class LLM(BaseLLM):
         This will set `litellm.success_callback` to ["langfuse", "langsmith"] and
         `litellm.failure_callback` to ["langfuse"].
         """
+        if not LITELLM_AVAILABLE:
+            # When litellm is not available, env callbacks have no effect
+            return
+
         with suppress_warnings():
             success_callbacks_str = os.environ.get("LITELLM_SUCCESS_CALLBACKS", "")
-            success_callbacks: list[str | Callable[..., Any] | CustomLogger] = []
+            success_callbacks: list[str | Callable[..., Any]] = []
             if success_callbacks_str:
                 success_callbacks = [
                     cb.strip() for cb in success_callbacks_str.split(",") if cb.strip()
@@ -2244,12 +2365,12 @@ class LLM(BaseLLM):
 
             failure_callbacks_str = os.environ.get("LITELLM_FAILURE_CALLBACKS", "")
             if failure_callbacks_str:
-                failure_callbacks: list[str | Callable[..., Any] | CustomLogger] = [
+                failure_callbacks: list[str | Callable[..., Any]] = [
                     cb.strip() for cb in failure_callbacks_str.split(",") if cb.strip()
                 ]
 
-                litellm.success_callback = success_callbacks
-                litellm.failure_callback = failure_callbacks
+                litellm.success_callback = success_callbacks  # type: ignore[assignment]
+                litellm.failure_callback = failure_callbacks  # type: ignore[assignment]
 
     def __copy__(self) -> LLM:
         """Create a shallow copy of the LLM instance."""
@@ -2398,6 +2519,9 @@ class LLM(BaseLLM):
             "gpt-4.1",
             "claude-3",
             "claude-4",
+            "claude-sonnet-4",
+            "claude-opus-4",
+            "claude-haiku-4",
             "gemini",
         )
         model_lower = self.model.lower()

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

@@ -152,6 +152,28 @@ class BaseLLM(ABC):
             "cached_prompt_tokens": 0,
         }
 
+    def to_config_dict(self) -> dict[str, Any]:
+        """Serialize this LLM to a dict that can reconstruct it via ``LLM(**config)``.
+
+        Returns the core fields that BaseLLM owns. Provider subclasses should
+        override this (calling ``super().to_config_dict()``) to add their own
+        fields (e.g. ``project``, ``location``, ``safety_settings``).
+        """
+        model = self.model
+        provider = self.provider
+        model_str = f"{provider}/{model}" if provider and "/" not in model else model
+
+        config: dict[str, Any] = {"model": model_str}
+
+        if self.temperature is not None:
+            config["temperature"] = self.temperature
+        if self.base_url is not None:
+            config["base_url"] = self.base_url
+        if self.stop:
+            config["stop"] = self.stop
+
+        return config
+
     @property
     def provider(self) -> str:
         """Get the provider of the LLM."""
@@ -619,7 +641,16 @@ class BaseLLM(ABC):
         Returns:
             Messages with files formatted into content blocks.
         """
-        if not HAS_CREWAI_FILES or not self.supports_multimodal():
+        if not HAS_CREWAI_FILES:
+            return messages
+
+        if not self.supports_multimodal():
+            if any(msg.get("files") for msg in messages):
+                raise ValueError(
+                    f"Model '{self.model}' does not support multimodal input, "
+                    "but files were provided via 'input_files'. "
+                    "Use a vision-capable model or remove the file inputs."
+                )
             return messages
 
         provider = getattr(self, "provider", None) or getattr(self, "model", "openai")

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

@@ -222,6 +222,7 @@ class AnthropicCompletion(BaseLLM):
         self.previous_thinking_blocks: list[ThinkingBlock] = []
         self.response_format = response_format
         # Tool search config
+        self.tool_search: AnthropicToolSearchConfig | None
         if tool_search is True:
             self.tool_search = AnthropicToolSearchConfig()
         elif isinstance(tool_search, AnthropicToolSearchConfig):
@@ -256,6 +257,19 @@ class AnthropicCompletion(BaseLLM):
         else:
             self.stop_sequences = []
 
+    def to_config_dict(self) -> dict[str, Any]:
+        """Extend base config with Anthropic-specific fields."""
+        config = super().to_config_dict()
+        if self.max_tokens != 4096:  # non-default
+            config["max_tokens"] = self.max_tokens
+        if self.max_retries != 2:  # non-default
+            config["max_retries"] = self.max_retries
+        if self.top_p is not None:
+            config["top_p"] = self.top_p
+        if self.timeout is not None:
+            config["timeout"] = self.timeout
+        return config
+
     def _get_client_params(self) -> dict[str, Any]:
         """Get client parameters."""
 
@@ -1753,7 +1767,14 @@ class AnthropicCompletion(BaseLLM):
         Returns:
             True if the model supports images and PDFs.
         """
-        return "claude-3" in self.model.lower() or "claude-4" in self.model.lower()
+        model_lower = self.model.lower()
+        return (
+            "claude-3" in model_lower
+            or "claude-4" in model_lower
+            or "claude-sonnet-4" in model_lower
+            or "claude-opus-4" in model_lower
+            or "claude-haiku-4" in model_lower
+        )
 
     def get_file_uploader(self) -> Any:
         """Get an Anthropic file uploader using this LLM's clients.

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

@@ -180,6 +180,27 @@ class AzureCompletion(BaseLLM):
             and "/openai/deployments/" in self.endpoint
         )
 
+    def to_config_dict(self) -> dict[str, Any]:
+        """Extend base config with Azure-specific fields."""
+        config = super().to_config_dict()
+        if self.endpoint:
+            config["endpoint"] = self.endpoint
+        if self.api_version and self.api_version != "2024-06-01":
+            config["api_version"] = self.api_version
+        if self.timeout is not None:
+            config["timeout"] = self.timeout
+        if self.max_retries != 2:
+            config["max_retries"] = self.max_retries
+        if self.top_p is not None:
+            config["top_p"] = self.top_p
+        if self.frequency_penalty is not None:
+            config["frequency_penalty"] = self.frequency_penalty
+        if self.presence_penalty is not None:
+            config["presence_penalty"] = self.presence_penalty
+        if self.max_tokens is not None:
+            config["max_tokens"] = self.max_tokens
+        return config
+
     @staticmethod
     def _validate_and_fix_endpoint(endpoint: str, model: str) -> str:
         """Validate and fix Azure endpoint URL format.

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

@@ -346,6 +346,23 @@ class BedrockCompletion(BaseLLM):
         # Handle inference profiles for newer models
         self.model_id = model
 
+    def to_config_dict(self) -> dict[str, Any]:
+        """Extend base config with Bedrock-specific fields."""
+        config = super().to_config_dict()
+        # NOTE: AWS credentials (access_key, secret_key, session_token) are
+        # intentionally excluded — they must come from env on resume.
+        if self.region_name and self.region_name != "us-east-1":
+            config["region_name"] = self.region_name
+        if self.max_tokens is not None:
+            config["max_tokens"] = self.max_tokens
+        if self.top_p is not None:
+            config["top_p"] = self.top_p
+        if self.top_k is not None:
+            config["top_k"] = self.top_k
+        if self.guardrail_config:
+            config["guardrail_config"] = self.guardrail_config
+        return config
+
     @property
     def stop(self) -> list[str]:
         """Get stop sequences sent to the API."""
@@ -1880,7 +1897,9 @@ class BedrockCompletion(BaseLLM):
                 # Anthropic (Claude) models reject assistant-last messages when
                 # tools are in the request. Append a user message so the
                 # Converse API accepts the payload.
-                elif "anthropic" in self.model.lower() or "claude" in self.model.lower():
+                elif (
+                    "anthropic" in self.model.lower() or "claude" in self.model.lower()
+                ):
                     converse_messages.append(
                         {
                             "role": "user",
@@ -2100,12 +2119,18 @@ class BedrockCompletion(BaseLLM):
         model_lower = self.model.lower()
         vision_models = (
             "anthropic.claude-3",
+            "anthropic.claude-sonnet-4",
+            "anthropic.claude-opus-4",
+            "anthropic.claude-haiku-4",
             "amazon.nova-lite",
             "amazon.nova-pro",
             "amazon.nova-premier",
             "us.amazon.nova-lite",
             "us.amazon.nova-pro",
             "us.amazon.nova-premier",
+            "us.anthropic.claude-sonnet-4",
+            "us.anthropic.claude-opus-4",
+            "us.anthropic.claude-haiku-4",
         )
         return any(model_lower.startswith(m) for m in vision_models)
 

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

@@ -176,6 +176,28 @@ class GeminiCompletion(BaseLLM):
         else:
             self.stop_sequences = []
 
+    def to_config_dict(self) -> dict[str, Any]:
+        """Extend base config with Gemini/Vertex-specific fields."""
+        config = super().to_config_dict()
+        if self.project:
+            config["project"] = self.project
+        if self.location and self.location != "us-central1":
+            config["location"] = self.location
+        if self.top_p is not None:
+            config["top_p"] = self.top_p
+        if self.top_k is not None:
+            config["top_k"] = self.top_k
+        if self.max_output_tokens is not None:
+            config["max_output_tokens"] = self.max_output_tokens
+        if self.safety_settings:
+            config["safety_settings"] = [
+                {"category": str(s.category), "threshold": str(s.threshold)}
+                if hasattr(s, "category") and hasattr(s, "threshold")
+                else s
+                for s in self.safety_settings
+            ]
+        return config
+
     def _initialize_client(self, use_vertexai: bool = False) -> genai.Client:
         """Initialize the Google Gen AI client with proper parameter handling.
 

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

@@ -329,6 +329,35 @@ class OpenAICompletion(BaseLLM):
         """
         self._last_reasoning_items = None
 
+    def to_config_dict(self) -> dict[str, Any]:
+        """Extend base config with OpenAI-specific fields."""
+        config = super().to_config_dict()
+        # Client-level params (from OpenAI SDK)
+        if self.organization:
+            config["organization"] = self.organization
+        if self.project:
+            config["project"] = self.project
+        if self.timeout is not None:
+            config["timeout"] = self.timeout
+        if self.max_retries != 2:
+            config["max_retries"] = self.max_retries
+        # Completion params
+        if self.top_p is not None:
+            config["top_p"] = self.top_p
+        if self.frequency_penalty is not None:
+            config["frequency_penalty"] = self.frequency_penalty
+        if self.presence_penalty is not None:
+            config["presence_penalty"] = self.presence_penalty
+        if self.max_tokens is not None:
+            config["max_tokens"] = self.max_tokens
+        if self.max_completion_tokens is not None:
+            config["max_completion_tokens"] = self.max_completion_tokens
+        if self.seed is not None:
+            config["seed"] = self.seed
+        if self.reasoning_effort is not None:
+            config["reasoning_effort"] = self.reasoning_effort
+        return config
+
     def _get_client_params(self) -> dict[str, Any]:
         """Get OpenAI client parameters."""
 

lib/crewai/src/crewai/llms/providers/openai_compatible/__init__.py

@@ -0,0 +1,14 @@
+"""OpenAI-compatible providers module."""
+
+from crewai.llms.providers.openai_compatible.completion import (
+    OPENAI_COMPATIBLE_PROVIDERS,
+    OpenAICompatibleCompletion,
+    ProviderConfig,
+)
+
+
+__all__ = [
+    "OPENAI_COMPATIBLE_PROVIDERS",
+    "OpenAICompatibleCompletion",
+    "ProviderConfig",
+]

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

@@ -0,0 +1,282 @@
+"""OpenAI-compatible providers implementation.
+
+This module provides a thin subclass of OpenAICompletion that supports
+various OpenAI-compatible APIs like OpenRouter, DeepSeek, Ollama, vLLM,
+Cerebras, and Dashscope (Alibaba/Qwen).
+
+Usage:
+    llm = LLM(model="deepseek/deepseek-chat")  # Uses DeepSeek API
+    llm = LLM(model="openrouter/anthropic/claude-3-opus")  # Uses OpenRouter
+    llm = LLM(model="ollama/llama3")  # Uses local Ollama
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import os
+from typing import Any
+
+from crewai.llms.providers.openai.completion import OpenAICompletion
+
+
+@dataclass(frozen=True)
+class ProviderConfig:
+    """Configuration for an OpenAI-compatible provider.
+
+    Attributes:
+        base_url: Default base URL for the provider's API endpoint.
+        api_key_env: Environment variable name for the API key.
+        base_url_env: Environment variable name for a custom base URL override.
+        default_headers: HTTP headers to include in all requests.
+        api_key_required: Whether an API key is required for this provider.
+        default_api_key: Default API key to use if none is provided and not required.
+    """
+
+    base_url: str
+    api_key_env: str
+    base_url_env: str | None = None
+    default_headers: dict[str, str] = field(default_factory=dict)
+    api_key_required: bool = True
+    default_api_key: str | None = None
+
+
+OPENAI_COMPATIBLE_PROVIDERS: dict[str, ProviderConfig] = {
+    "openrouter": ProviderConfig(
+        base_url="https://openrouter.ai/api/v1",
+        api_key_env="OPENROUTER_API_KEY",
+        base_url_env="OPENROUTER_BASE_URL",
+        default_headers={"HTTP-Referer": "https://crewai.com"},
+        api_key_required=True,
+    ),
+    "deepseek": ProviderConfig(
+        base_url="https://api.deepseek.com/v1",
+        api_key_env="DEEPSEEK_API_KEY",
+        base_url_env="DEEPSEEK_BASE_URL",
+        api_key_required=True,
+    ),
+    "ollama": ProviderConfig(
+        base_url="http://localhost:11434/v1",
+        api_key_env="OLLAMA_API_KEY",
+        base_url_env="OLLAMA_HOST",
+        api_key_required=False,
+        default_api_key="ollama",
+    ),
+    "ollama_chat": ProviderConfig(
+        base_url="http://localhost:11434/v1",
+        api_key_env="OLLAMA_API_KEY",
+        base_url_env="OLLAMA_HOST",
+        api_key_required=False,
+        default_api_key="ollama",
+    ),
+    "hosted_vllm": ProviderConfig(
+        base_url="http://localhost:8000/v1",
+        api_key_env="VLLM_API_KEY",
+        base_url_env="VLLM_BASE_URL",
+        api_key_required=False,
+        default_api_key="dummy",
+    ),
+    "cerebras": ProviderConfig(
+        base_url="https://api.cerebras.ai/v1",
+        api_key_env="CEREBRAS_API_KEY",
+        base_url_env="CEREBRAS_BASE_URL",
+        api_key_required=True,
+    ),
+    "dashscope": ProviderConfig(
+        base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+        api_key_env="DASHSCOPE_API_KEY",
+        base_url_env="DASHSCOPE_BASE_URL",
+        api_key_required=True,
+    ),
+}
+
+
+def _normalize_ollama_base_url(base_url: str) -> str:
+    """Normalize Ollama base URL to ensure it ends with /v1.
+
+    Ollama uses OLLAMA_HOST which may not include the /v1 suffix,
+    but the OpenAI-compatible endpoint requires it.
+
+    Args:
+        base_url: The base URL, potentially without /v1 suffix.
+
+    Returns:
+        The base URL with /v1 suffix if needed.
+    """
+    base_url = base_url.rstrip("/")
+    if not base_url.endswith("/v1"):
+        return f"{base_url}/v1"
+    return base_url
+
+
+class OpenAICompatibleCompletion(OpenAICompletion):
+    """OpenAI-compatible completion implementation.
+
+    This class provides support for various OpenAI-compatible APIs by
+    automatically configuring the base URL, API key, and headers based
+    on the provider name.
+
+    Supported providers:
+        - openrouter: OpenRouter (https://openrouter.ai)
+        - deepseek: DeepSeek (https://deepseek.com)
+        - ollama: Ollama local server (https://ollama.ai)
+        - ollama_chat: Alias for ollama
+        - hosted_vllm: vLLM server (https://github.com/vllm-project/vllm)
+        - cerebras: Cerebras (https://cerebras.ai)
+        - dashscope: Alibaba Dashscope/Qwen (https://dashscope.aliyun.com)
+
+    Example:
+        # Using provider prefix
+        llm = LLM(model="deepseek/deepseek-chat")
+
+        # Using explicit provider parameter
+        llm = LLM(model="llama3", provider="ollama")
+
+        # With custom configuration
+        llm = LLM(
+            model="deepseek-chat",
+            provider="deepseek",
+            api_key="my-key",
+            temperature=0.7
+        )
+    """
+
+    def __init__(
+        self,
+        model: str,
+        provider: str,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        default_headers: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize OpenAI-compatible completion client.
+
+        Args:
+            model: The model identifier.
+            provider: The provider name (must be in OPENAI_COMPATIBLE_PROVIDERS).
+            api_key: Optional API key override. If not provided, uses the
+                provider's configured environment variable.
+            base_url: Optional base URL override. If not provided, uses the
+                provider's configured default or environment variable.
+            default_headers: Optional headers to merge with provider defaults.
+            **kwargs: Additional arguments passed to OpenAICompletion.
+
+        Raises:
+            ValueError: If the provider is not supported or required API key
+                is missing.
+        """
+        config = OPENAI_COMPATIBLE_PROVIDERS.get(provider)
+        if config is None:
+            supported = ", ".join(sorted(OPENAI_COMPATIBLE_PROVIDERS.keys()))
+            raise ValueError(
+                f"Unknown OpenAI-compatible provider: {provider}. "
+                f"Supported providers: {supported}"
+            )
+
+        resolved_api_key = self._resolve_api_key(api_key, config, provider)
+        resolved_base_url = self._resolve_base_url(base_url, config, provider)
+        resolved_headers = self._resolve_headers(default_headers, config)
+
+        super().__init__(
+            model=model,
+            provider=provider,
+            api_key=resolved_api_key,
+            base_url=resolved_base_url,
+            default_headers=resolved_headers,
+            **kwargs,
+        )
+
+    def _resolve_api_key(
+        self,
+        api_key: str | None,
+        config: ProviderConfig,
+        provider: str,
+    ) -> str | None:
+        """Resolve the API key from explicit value, env var, or default.
+
+        Args:
+            api_key: Explicitly provided API key.
+            config: Provider configuration.
+            provider: Provider name for error messages.
+
+        Returns:
+            The resolved API key.
+
+        Raises:
+            ValueError: If API key is required but not found.
+        """
+        if api_key:
+            return api_key
+
+        env_key = os.getenv(config.api_key_env)
+        if env_key:
+            return env_key
+
+        if config.api_key_required:
+            raise ValueError(
+                f"API key required for {provider}. "
+                f"Set {config.api_key_env} environment variable or pass api_key parameter."
+            )
+
+        return config.default_api_key
+
+    def _resolve_base_url(
+        self,
+        base_url: str | None,
+        config: ProviderConfig,
+        provider: str,
+    ) -> str:
+        """Resolve the base URL from explicit value, env var, or default.
+
+        Args:
+            base_url: Explicitly provided base URL.
+            config: Provider configuration.
+            provider: Provider name (used for special handling like Ollama).
+
+        Returns:
+            The resolved base URL.
+        """
+        if base_url:
+            resolved = base_url
+        elif config.base_url_env:
+            resolved = os.getenv(config.base_url_env, config.base_url)
+        else:
+            resolved = config.base_url
+
+        if provider in ("ollama", "ollama_chat"):
+            resolved = _normalize_ollama_base_url(resolved)
+
+        return resolved
+
+    def _resolve_headers(
+        self,
+        headers: dict[str, str] | None,
+        config: ProviderConfig,
+    ) -> dict[str, str] | None:
+        """Merge user headers with provider default headers.
+
+        Args:
+            headers: User-provided headers.
+            config: Provider configuration.
+
+        Returns:
+            Merged headers dict, or None if empty.
+        """
+        if not config.default_headers and not headers:
+            return None
+
+        merged = dict(config.default_headers)
+        if headers:
+            merged.update(headers)
+
+        return merged if merged else None
+
+    def supports_function_calling(self) -> bool:
+        """Check if the provider supports function calling.
+
+        All modern OpenAI-compatible providers support function calling.
+
+        Returns:
+            True, as all supported providers have function calling support.
+        """
+        return True

lib/crewai/src/crewai/mcp/client.py

@@ -1,22 +1,21 @@
 """MCP client with session management for CrewAI agents."""
 
 import asyncio
-from collections.abc import Callable
+from collections.abc import Callable, Coroutine
 from contextlib import AsyncExitStack
 from datetime import datetime
 import logging
+import sys
 import time
-from typing import Any, NamedTuple
+from typing import Any, NamedTuple, TypeVar
 
 from typing_extensions import Self
 
 
-# BaseExceptionGroup is available in Python 3.11+
-try:
+if sys.version_info >= (3, 11):
     from builtins import BaseExceptionGroup
-except ImportError:
-    # Fallback for Python < 3.11 (shouldn't happen in practice)
-    BaseExceptionGroup = Exception
+else:
+    from exceptiongroup import BaseExceptionGroup
 
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.mcp_events import (
@@ -47,8 +46,10 @@ MCP_TOOL_EXECUTION_TIMEOUT = 30
 MCP_DISCOVERY_TIMEOUT = 30  # Increased for slow servers
 MCP_MAX_RETRIES = 3
 
+_T = TypeVar("_T")
+
 # Simple in-memory cache for MCP tool schemas (duration: 5 minutes)
-_mcp_schema_cache: dict[str, tuple[dict[str, Any], float]] = {}
+_mcp_schema_cache: dict[str, tuple[list[dict[str, Any]], float]] = {}
 _cache_ttl = 300  # 5 minutes
 
 
@@ -134,11 +135,7 @@ class MCPClient:
         else:
             server_name = "Unknown MCP Server"
             server_url = None
-            transport_type = (
-                self.transport.transport_type.value
-                if hasattr(self.transport, "transport_type")
-                else None
-            )
+            transport_type = self.transport.transport_type.value
 
         return server_name, server_url, transport_type
 
@@ -542,7 +539,7 @@ class MCPClient:
         Returns:
             Cleaned arguments ready for MCP server.
         """
-        cleaned = {}
+        cleaned: dict[str, Any] = {}
 
         for key, value in arguments.items():
             # Skip None values
@@ -686,9 +683,9 @@ class MCPClient:
 
     async def _retry_operation(
         self,
-        operation: Callable[[], Any],
+        operation: Callable[[], Coroutine[Any, Any, _T]],
         timeout: int | None = None,
-    ) -> Any:
+    ) -> _T:
         """Retry an operation with exponential backoff.
 
         Args:

lib/crewai/src/crewai/mcp/tool_resolver.py

@@ -23,6 +23,7 @@ from crewai.mcp.config import (
     MCPServerSSE,
     MCPServerStdio,
 )
+from crewai.mcp.transports.base import BaseTransport
 from crewai.mcp.transports.http import HTTPTransport
 from crewai.mcp.transports.sse import SSETransport
 from crewai.mcp.transports.stdio import StdioTransport
@@ -285,6 +286,7 @@ class MCPToolResolver:
         independent transport so that parallel tool executions never share
         state.
         """
+        transport: BaseTransport
         if isinstance(mcp_config, MCPServerStdio):
             transport = StdioTransport(
                 command=mcp_config.command,

lib/crewai/src/crewai/mcp/transports/base.py

@@ -2,11 +2,17 @@
 
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Any, Protocol
+from typing import Any
 
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from mcp.shared.message import SessionMessage
 from typing_extensions import Self
 
 
+MCPReadStream = MemoryObjectReceiveStream[SessionMessage | Exception]
+MCPWriteStream = MemoryObjectSendStream[SessionMessage]
+
+
 class TransportType(str, Enum):
     """MCP transport types."""
 
@@ -16,22 +22,6 @@ class TransportType(str, Enum):
     SSE = "sse"
 
 
-class ReadStream(Protocol):
-    """Protocol for read streams."""
-
-    async def read(self, n: int = -1) -> bytes:
-        """Read bytes from stream."""
-        ...
-
-
-class WriteStream(Protocol):
-    """Protocol for write streams."""
-
-    async def write(self, data: bytes) -> None:
-        """Write bytes to stream."""
-        ...
-
-
 class BaseTransport(ABC):
     """Base class for MCP transport implementations.
 
@@ -46,8 +36,8 @@ class BaseTransport(ABC):
         Args:
             **kwargs: Transport-specific configuration options.
         """
-        self._read_stream: ReadStream | None = None
-        self._write_stream: WriteStream | None = None
+        self._read_stream: MCPReadStream | None = None
+        self._write_stream: MCPWriteStream | None = None
         self._connected = False
 
     @property
@@ -62,14 +52,14 @@ class BaseTransport(ABC):
         return self._connected
 
     @property
-    def read_stream(self) -> ReadStream:
+    def read_stream(self) -> MCPReadStream:
         """Get the read stream."""
         if self._read_stream is None:
             raise RuntimeError("Transport not connected. Call connect() first.")
         return self._read_stream
 
     @property
-    def write_stream(self) -> WriteStream:
+    def write_stream(self) -> MCPWriteStream:
         """Get the write stream."""
         if self._write_stream is None:
             raise RuntimeError("Transport not connected. Call connect() first.")
@@ -107,7 +97,7 @@ class BaseTransport(ABC):
         """Async context manager exit."""
         ...
 
-    def _set_streams(self, read: ReadStream, write: WriteStream) -> None:
+    def _set_streams(self, read: MCPReadStream, write: MCPWriteStream) -> None:
         """Set the read and write streams.
 
         Args:

lib/crewai/src/crewai/mcp/transports/http.py

@@ -1,17 +1,16 @@
 """HTTP and Streamable HTTP transport for MCP servers."""
 
 import asyncio
+import sys
 from typing import Any
 
 from typing_extensions import Self
 
 
-# BaseExceptionGroup is available in Python 3.11+
-try:
+if sys.version_info >= (3, 11):
     from builtins import BaseExceptionGroup
-except ImportError:
-    # Fallback for Python < 3.11 (shouldn't happen in practice)
-    BaseExceptionGroup = Exception
+else:
+    from exceptiongroup import BaseExceptionGroup
 
 from crewai.mcp.transports.base import BaseTransport, TransportType
 

lib/crewai/src/crewai/mcp/transports/stdio.py

@@ -122,11 +122,14 @@ class StdioTransport(BaseTransport):
             if self._process is not None:
                 try:
                     self._process.terminate()
+                    loop = asyncio.get_running_loop()
                     try:
-                        await asyncio.wait_for(self._process.wait(), timeout=5.0)
+                        await asyncio.wait_for(
+                            loop.run_in_executor(None, self._process.wait), timeout=5.0
+                        )
                     except asyncio.TimeoutError:
                         self._process.kill()
-                        await self._process.wait()
+                        await loop.run_in_executor(None, self._process.wait)
                 # except ProcessLookupError:
                 #     pass
                 finally:

lib/crewai/src/crewai/memory/encoding_flow.py

@@ -28,6 +28,7 @@ from crewai.memory.analyze import (
     analyze_for_save,
 )
 from crewai.memory.types import MemoryConfig, MemoryRecord, embed_texts
+from crewai.memory.utils import join_scope_paths
 
 
 logger = logging.getLogger(__name__)
@@ -48,6 +49,8 @@ class ItemState(BaseModel):
     importance: float | None = None
     source: str | None = None
     private: bool = False
+    # Structural root scope prefix for hierarchical scoping
+    root_scope: str | None = None
     # Resolved values
     resolved_scope: str = "/"
     resolved_categories: list[str] = Field(default_factory=list)
@@ -104,6 +107,14 @@ class EncodingFlow(Flow[EncodingState]):
         embedder: Any,
         config: MemoryConfig | None = None,
     ) -> None:
+        """Initialize the encoding flow.
+
+        Args:
+            storage: Storage backend for persisting memories.
+            llm: LLM instance for analysis.
+            embedder: Embedder for generating vectors.
+            config: Optional memory configuration.
+        """
         super().__init__(suppress_flow_events=True)
         self._storage = storage
         self._llm = llm
@@ -180,10 +191,18 @@ class EncodingFlow(Flow[EncodingState]):
         def _search_one(
             item: ItemState,
         ) -> list[tuple[MemoryRecord, float]]:
-            scope_prefix = item.scope if item.scope and item.scope.strip("/") else None
+            # Use root_scope as the search boundary, then narrow by explicit scope if provided
+            effective_prefix = None
+            if item.root_scope:
+                effective_prefix = item.root_scope.rstrip("/")
+                if item.scope and item.scope.strip("/"):
+                    effective_prefix = effective_prefix + "/" + item.scope.strip("/")
+            elif item.scope and item.scope.strip("/"):
+                effective_prefix = item.scope
+
             return self._storage.search(  # type: ignore[no-any-return]
                 item.embedding,
-                scope_prefix=scope_prefix,
+                scope_prefix=effective_prefix,
                 categories=None,
                 limit=self._config.consolidation_limit,
                 min_score=0.0,
@@ -253,9 +272,16 @@ class EncodingFlow(Flow[EncodingState]):
         existing_scopes: list[str] = []
         existing_categories: list[str] = []
         if any_needs_fields:
-            existing_scopes = self._storage.list_scopes("/") or ["/"]
+            # Constrain scope/category suggestions to root_scope boundary
+            # Check if any active item has root_scope
+            active_root = next(
+                (it.root_scope for it in items if not it.dropped and it.root_scope),
+                None,
+            )
+            scope_search_root = active_root if active_root else "/"
+            existing_scopes = self._storage.list_scopes(scope_search_root) or ["/"]
             existing_categories = list(
-                self._storage.list_categories(scope_prefix=None).keys()
+                self._storage.list_categories(scope_prefix=active_root).keys()
             )
 
         # Classify items and submit LLM calls
@@ -321,7 +347,13 @@ class EncodingFlow(Flow[EncodingState]):
             for i, future in save_futures.items():
                 analysis = future.result()
                 item = items[i]
-                item.resolved_scope = item.scope or analysis.suggested_scope or "/"
+                # Determine inner scope from explicit scope or LLM-inferred
+                inner_scope = item.scope or analysis.suggested_scope or "/"
+                # Join root_scope with inner scope if root_scope is set
+                if item.root_scope:
+                    item.resolved_scope = join_scope_paths(item.root_scope, inner_scope)
+                else:
+                    item.resolved_scope = inner_scope
                 item.resolved_categories = (
                     item.categories
                     if item.categories is not None
@@ -353,8 +385,18 @@ class EncodingFlow(Flow[EncodingState]):
             pool.shutdown(wait=False)
 
     def _apply_defaults(self, item: ItemState) -> None:
-        """Apply caller values with config defaults (fast path)."""
-        item.resolved_scope = item.scope or "/"
+        """Apply caller values with config defaults (fast path).
+
+        If root_scope is set, prepends it to the inner scope to create the
+        final resolved_scope.
+        """
+        inner_scope = item.scope or "/"
+        # Join root_scope with inner scope if root_scope is set
+        if item.root_scope:
+            item.resolved_scope = join_scope_paths(item.root_scope, inner_scope)
+        else:
+            item.resolved_scope = inner_scope if inner_scope != "/" else "/"
+
         item.resolved_categories = item.categories or []
         item.resolved_metadata = item.metadata or {}
         item.resolved_importance = (