- Add debug logging for better tracing in ReAct pattern
- Simplify action requirements format when tools are available
- Improve anyOf/oneOf handling for Claude tool schemas
- Handle Union[str, List[str]] types properly
- General code formatting improvements from ruff

- Add stream_chat support to MockReActLLM and MockLLM in tests
- Fix string response parsing to prioritize JSON extraction
- Properly handle final_answer with success/error fields
- Update test expectations for invalid/truncated JSON in native mode
- Add create_mock_stream_chat helper for DAG tests

All 30 tests now pass with native tool calling enabled.

- Extract reasoning from full_content before tool calls
- Pass reasoning through response object to action converter
- Use actual LLM reasoning instead of hardcoded placeholder
- Update prompt to only require type and reasoning in JSON
- Add reasoning field to action execution traces
- Ensure reasoning is available in final answer results

This fixes the issue where LLM reasoning was lost when using
native function calling, as the OpenAI API format doesn't include
reasoning in tool_calls. Now reasoning is captured from the text
content LLM generates before invoking tools.

This change separates the action type decision from tool invocation:

1. First LLM call: Determine action type (tool_call vs final_answer)
   - Returns JSON with action type and reasoning
   - No tool schemas passed

2. Second LLM call (if tool_call): Invoke specific tool via native calling
   - Pass tool schemas to LLM
   - LLM uses native function calling API
   - Returns tool_calls with tool_name and arguments

Benefits:
- Clearer separation of concerns
- Better reasoning capture (not lost in native tool call format)
- More predictable LLM behavior
- Easier to debug and trace

Tests updated to reflect 3-call pattern:
- Call 1: Action type
- Call 2: Native tool invocation
- Call 3: Final answer

- Fix: Clean messages_with_prompt instead of messages in second call
- Simplify first call prompt to focus on action type decision only
- Remove confusing instructions about tool calling in first call
- Clarify that system will guide tool invocation in follow-up call

…ling

Remove verbose debug logging from the first and second LLM calls while
preserving important warnings and errors. The changes include:
- Remove tool availability and name logs
- Remove response type/value debug logs
- Remove json_repair success logs
- Remove token chunk logs
- Remove second call info logs

Keep critical logs for validation failures, unknown types, and errors.

…empty

Add guard check before accessing accumulated_tool_calls.keys()[0] when
event.index is not available. If accumulated_tool_calls is empty, skip
the chunk instead of raising IndexError.

…tibility

- Only use two-phase tool calling when step_id == "main" (top-level ReAct)
- Skip second call for DAG steps to maintain backward compatibility
- This fixes DAG tests that expect single-phase tool calling behavior
- Also fix potential IndexError in claude.py when accumulated_tool_calls is empty

In DAG mode (step_id != "main"), use traditional single-phase tool calling
where tools are passed to the LLM from the start. This maintains backward
compatibility with DAG tests and avoids infinite retry loops.

In main ReAct mode (step_id == "main"), use two-phase tool calling:
- First call: JSON format to decide action type
- Second call: Native tool calling to invoke the tool

This fixes the issue where DAG steps were executing tools in a loop.

- refactor(claude): extract duplicated anyOf/oneOf handling into
  _handle_union_type() helper (~85 lines reduced)
- fix(openai): skip unassociable tool call chunks instead of creating
  entries with empty string keys
- fix(react): shorten observation instructional text while keeping
  behavioral nudge to prevent tool loops
- fix(react): add missing required 'reasoning' field in
  _normalize_action_data() fallback dicts to prevent ValidationError
- fix(react): remove stale comment about missing task_id/step_id access
- fix(test): prevent infinite tool call loop in DAG sequential test
  by tracking executed tools in mock LLM