Handle LLM stream chunk event - display streaming text in a panel. Args: chunk: The new chunk of text received. accum

Increment the delegations counter.

Initialize a Git repository when Git is available.

Inject A2A server methods onto an Agent instance. Adds a `to_agent_card(url: str) -> AgentCard` method to the agent that generates an A2A-com

Install the crew by running the UV command to lock and install.

Interpolate inputs into the task description, expected output, and output file path. Add conversation history if present. Args:

Execute agent asynchronously with given inputs. This method is designed for use within async contexts, such as when the agent is call

Check if this extension is active for the current request. An extension is active if the client declared support for it. Args:

Check if the object carries Flow method wrapper metadata.

Check if Git is installed and available in the system.

Prompt only in an interactive terminal, never in non-interactive mode.

Return True if the current context is dispatching a replayed event. Listeners with side effects (checkpoint writes, external API calls that s

Executes the Crew's workflow for each input asynchronously. Args: inputs: List of input dictionaries, one per execution.

Show locally installed skills.

List all available crews.

List all uploaded files. Returns: List of dictionaries with file information.

List available tools from MCP server. Args: use_cache: Whether to use cached results. If None, uses client's cach

Load a JSON or JSONC file.

Load a vendored A2UI JSON schema by name and version. Args: name: Schema name without extension, e.g. ``"server_to_client"``. ver

Promote a skill to RESOURCES disclosure level. Catalogs available resource directories (scripts, references, assets). Args: skill: S

Observe a step's result and decide on plan continuation. This runs after EVERY step execution — not just failures. Args:

Unregister an event handler for a specific event type. Args: event_type: The event class to stop listening for handle

Decorator to register an event handler for a specific event type. Handlers can accept 2 or 3 arguments: - ``(source, event)`` — s

Arrow-key single-select from plain labels. Returns: Selected index, or ``-1`` if cancelled.

Process multiple files according to constraints. Args: files: Dictionary mapping names to file inputs. Returns:

Stream file content in chunks without loading entirely into memory. Args: chunk_size: Size of each chunk in bytes. Yield

Store one or more items in memory. Pass a single string for synchronous save (returns the MemoryRecord). Pass a list of strings for n

Remember content; scope is relative to this scope's root.

Render a template file using ``{{placeholder}}`` replacements.

Reset the entire backing memory store, ignoring ``root_scope``.

Return the CrewAI AMP client to use, or build ``default``. Hosted runtimes install a client of their own through ``_create_plus_client_hook``

Execute an explicit list of hooks against a context. This is the shared engine used both by :func:`dispatch` (which resolves global + scoped

Sanitize a JSON schema for Anthropic strict tool use.

Persist the flow state after method completion. Args: flow_uuid: Unique identifier for the flow instance method_name:

Search for memories by vector similarity with optional filters. Args: query_embedding: Embedding vector for the query.

Attempt to keep a single set of callbacks in litellm by removing old duplicates and adding new ones. Note: This only affects

Set the emission counter to resume from a given value.

Set the RuntimeState that will be passed to event handlers.

Return True if console output should currently be suppressed.

Append a user message and stream one conversational turn as frames.

Check if the LLM supports stop words. Returns: True if the LLM supports stop words, False otherwise.

Check if the model supports stop words.

Test and evaluate the Crew with the given inputs for n iterations. Uses concurrent.futures for concurrent execution.

Serialize this LLM to a dict that can reconstruct it via ``LLM(**config)``. Returns the core fields that BaseLLM owns. Provider subclasses sh

Convert a list of tools to CrewStructuredTool instances.

Records when a tool usage results in an error. Args: llm: The language model being used when the error occurred. agen

Track delegation if the tool is a delegation tool. Args: tool_name: Name of the tool being executed. tool_args: Arguments passed

Trains the crew for a given number of iterations.

Unregister a specific global after_llm_call hook. Args: hook: The hook function to remove Returns: True if the hook was foun

Unregister a specific global before_llm_call hook. Args: hook: The hook function to remove Returns: True if the hook was fou

Return whether provider/API should use OpenAI Responses file support.

Validate that a directory name matches the skill name. Args: skill_dir: Path to the skill directory. skill_name: The declared ski

Validate a PDF file against constraints. Args: file: The PDF file to validate. constraints: PDF constraints to validate against.

Return True when two skill versions refer to the same version. Versions arrive as ``1.2.0`` or ``v1.2.0`` depending on whether they came from

Wait for batch to be initialized. Args: timeout: Maximum time to wait in seconds (default: 2.0) Returns: Tru

Create a new Skill at a different disclosure level. Args: level: The new disclosure level. instructions: Optional ins

Ensure cleanup on deletion.

Support the descriptor protocol for method binding. This allows the wrapped method to be properly bound to an instance when accessed

Initialize the CustomLLM with a predefined response. Args: response: The predefined response to return from call().

Async call to OpenAI Responses API.

Add propertyOrdering to JSON schema for Gemini 2.0 compatibility. Gemini 2.0 models require an explicit propertyOrdering list to define

Add the internal loader used for request-scoped skill disclosure.

Async version of _delegate_to_a2a.

Execute a task without a timeout asynchronously. Args: task_prompt: The prompt to send to the agent. task: The task b

Async equivalent of ``_export_output`` — uses ``acall`` so the event loop is not blocked.

Cached async implementation of AgentCard fetching.

Fetch agent cards concurrently for multiple A2A agents using asyncio.

Handle async non-streaming converse API call.

Process human feedback asynchronously and refine answer. Args: formatted_answer: Initial agent result. Returns:

Async inject files into the last user message.

Invoke the agent loop asynchronously and return the result.

Execute agent loop asynchronously using ReAct text-based pattern. Returns: Final answer from the agent.

Invoke step callback (async context). Args: formatted_answer: Current agent response.

Add text tool-calling instructions after native tools are rejected.

Query the LLM for a specific field value based on its description. Args: field_name: The name of the field to extract.

Summarize multiple message chunks concurrently using asyncio. Args: chunks: List of message chunks to summarize. llm: LLM instanc

Wire an ``LLMCallCompletedEvent`` listener for the duration of one ``kickoff_async`` call.

Run the encoding pipeline in a background thread with event emission. Both started and completed events are emitted here (in the background

Emit the start event and return the invariant context for a checkpoint.