Feature: LangGraph nodes coverage
  As a developer
  I want to cover uncovered branches in langgraph nodes
  So that node behaviors are verified and coverage improves

  Scenario: Conversation history truncates by message count
    Given a node with history limit 2 messages
    And a conversation history of 3 short messages
    When I prepare the conversation history
    Then it should return 2 messages and indicate truncation

  Scenario: Agent node falls back when agent instance is missing
    Given an agent node referencing a missing agent
    When I execute the agent node
    Then it should return a not found assistant message

  Scenario: Tool agent uses current_message metadata for input
    Given a tool agent node with a current_message "override" and long history
    When I execute the tool agent node
    Then the tool agent should receive input "override"
    And the response metadata should include last_agent_node

  Scenario: Function node runs async function
    Given a function node with an async function
    When I execute the function node
    Then the function result message should be "async-result"

  Scenario: Function node awaits coroutine returned from sync function
    Given a function node with a sync function that returns a coroutine
    When I execute the function node
    Then the function result message should be "sync-inner"

  Scenario: Conditional node detects assistant field match
    Given a conditional node looking for field "status" equals "OK"
    When I execute the conditional node with matching assistant message
    Then the condition_result should be true and metadata flagged

  Scenario: Message router selects rule based on field condition
    Given a message router node with a rule matching field "topic" value "urgent"
    When I execute the message router with current_message containing topic "urgent"
    Then it should route to "urgent_node"

  Scenario: Edge condition checks equals against latest message
    Given an edge with equals condition on field "content" value "done"
    When I evaluate the edge condition with matching last message
    Then the edge condition should be true
    And evaluating with no messages should also default to true

  Scenario: Eval condition supports equals and field comparisons
    Given I evaluate equals condition on message "abc"
    Then the equals evaluation should return true
    When I evaluate field condition on message dict with foo value "bar"
    Then the field evaluation should return true
    When I evaluate field condition on non-dict message
    Then it should return false

  Scenario: Node parallel execution flag reflects configuration
    Given a node configured for parallel execution
    Then can_execute_parallel should return true