fix(openapi): support non-object request bodies and stop body data loss on parameter name collisions

[K4bain]

Fixes #319 (both parts).

Root cause

Two related defects in how requestBody is projected and executed:

1. Non-object bodies are dropped. The conversion loop only reads schema["properties"] — a top-level array (List[Item] = Body(...)) or a primitive body (Pydantic __root__ model) has no properties, so the tool was generated with no body arguments at all. The endpoint was unreachable: the LLM had no way to supply the payload.
2. Execution deletes colliding body fields. Path/query/header parameters and body fields are flattened into one inputSchema. When a body field shares a name with a path parameter (e.g. item_id in both /orders/{item_id} and the body model), the executor's arguments.pop(param_name) consumed the value while building the path URL — and the body payload then went out without the field, so FastAPI answered 422 Unprocessable Entity.

The fix

Schema conversion (convert.py)

• Non-object bodies map to a single payload argument carrying the body schema verbatim (falls back to requestBody if a route parameter is named payload). Purely additive: these tools previously had no body input at all.
• The operation map now records body_param_names (which flattened arguments belong to the body) and raw_body_argument (set for non-object bodies).
• On a body/route name collision, the route parameter keeps the inputSchema slot and a warning is logged. Nesting the body under its own namespace would fully separate the names, but that changes the tool schema shape for every existing consumer — a breaking change I deliberately left out (happy to do it behind an opt-in flag if maintainers want it).

Execution (server.py)

• The body is rebuilt from body_param_names before routing parameters are popped, so a colliding body field reaches the body as well as the path.
• Non-object bodies pass through verbatim (json=<the array/primitive>, not nested).
• Operation maps without the new metadata (hand-constructed or from older versions) keep the exact historical leftover-arguments behavior — no breaking change for downstream users of operation_map.

Test contract fix

test_execute_api_tool_with_body previously asserted the old inconsistent behavior: the tool's advertised inputSchema flattens the Item model's fields, but the test supplied {"item": {...}} and expected it forwarded verbatim — a payload the real endpoint would reject with 422. The test now sends what the schema advertises (which is also what http://localhost FastAPI actually expects), and the executor forwards exactly the declared body fields.

Verification

• Executor-level regression tests: colliding body field survives the path pop (json == {"item_id": 42, "quantity": 7} while URL becomes /orders/42), raw array body passes through unwrapped, legacy map keeps leftover behavior.
• Schema-level regression tests: array body → payload argument with body_param_names/raw_body_argument metadata; collision → route param keeps the slot + metadata records both body fields.
• Full non-transport suite green (82 passed in the affected files); ruff check + format clean; mypy clean. (The real-transport SSE/HTTP suites error on this Windows checkout identically on clean main — subprocess fork contexts, unrelated to this change.)

[K4bain]

Closing for housekeeping - the repo had no reviewer engagement and we are re-approaching these areas through a narrower pipeline. Happy to reopen on request.