Feature: Actor-first port of v2 agent and LangGraph suites
  As a developer migrating v2 agent flows
  I want actor-only agent and LangGraph coverage
  So that v3 matches the v2 behaviors without provider/model flags

  Background:
    Given the agent system is initialized with actor-first configuration

  # From langgraph_state_management.feature
  Scenario: LangGraph with actor-based state management
    Given I have a stateful LangGraph configuration:
      """
      {
        "name": "stateful_graph",
        "actor": "openai/gpt-4",
        "checkpointing": true,
        "enable_time_travel": true,
        "nodes": {
          "accumulate": {
            "type": "function",
            "function": "add_to_state"
          }
        },
        "edges": [
          {"source": "start", "target": "accumulate"},
          {"source": "accumulate", "target": "end"}
        ]
      }
      """
    When I create the stateful graph
    Then the graph should be created with actor "openai/gpt-4"
    And the graph state should be persisted
    And time travel should be enabled

  # From agent_modules_coverage.feature
  Scenario: Create agent with actor configuration
    Given I have an agent configuration:
      """
      {
        "name": "test_agent",
        "type": "base",
        "actor": "anthropic/claude-3"
      }
      """
    When I create an agent from the configuration
    Then the agent should be created successfully
    And the agent should use actor "anthropic/claude-3"
    And the agent module should be accessible

  # From chain_agent_comprehensive.feature
  Scenario: Chain agent with actor and steps
    Given I have a chain agent configuration:
      """
      {
        "name": "test_chain",
        "type": "chain",
        "actor": "openai/gpt-3.5-turbo",
        "steps": ["validate", "transform", "output"],
        "prompt": "Process this: {message}"
      }
      """
    When I create a chain agent from the configuration
    Then the chain agent should be created successfully
    And the chain agent should have 3 steps
    And the chain agent should use actor "openai/gpt-3.5-turbo"

  Scenario: Process message with actor-based chain agent
    Given I have a chain agent with actor "local/custom-processor"
    And the chain has steps ["parse", "analyze", "format"]
    When I process the message "Test input"
    Then the chain should use the specified actor
    And the result should show processing through all steps

  # From composite_agent_coverage.feature pattern
  Scenario: Composite agent with multiple actors
    Given I have a composite agent configuration:
      """
      {
        "name": "multi_actor_composite",
        "type": "composite",
        "agents": [
          {
            "name": "analyzer",
            "actor": "openai/gpt-4",
            "role": "analyze"
          },
          {
            "name": "generator",
            "actor": "anthropic/claude-3",
            "role": "generate"
          },
          {
            "name": "validator",
            "actor": "local/validator",
            "role": "validate"
          }
        ]
      }
      """
    When I create a composite agent from the configuration
    Then the composite agent should have 3 sub-agents
    And each sub-agent should use its configured actor
    And parallel processing should work with all actors

  # From reactive_agents.feature pattern
  Scenario: Reactive agent with actor-based streaming
    Given I have a reactive agent configuration:
      """
      {
        "name": "stream_agent",
        "type": "reactive",
        "actor": "openai/gpt-4",
        "stream_config": {
          "stream_type": "transform",
          "operators": ["map", "filter", "reduce"]
        }
      }
      """
    When I create a reactive agent from the configuration
    Then the agent should support reactive streaming
    And the stream should use actor "openai/gpt-4"
    And operators should transform data through the actor

  # From tool_agent.feature pattern
  Scenario: Tool agent with actor and tool configuration
    Given I have a tool agent configuration:
      """
      {
        "name": "tool_agent",
        "type": "tool",
        "actor": "openai/gpt-4",
        "tools": [
          {
            "name": "calculator",
            "type": "function",
            "function": "calculate"
          },
          {
            "name": "search",
            "type": "api",
            "endpoint": "search_api"
          }
        ]
      }
      """
    When I create a tool agent from the configuration
    Then the tool agent should have 2 tools available
    And the tool agent should use actor "openai/gpt-4"
    And tool calls should be routed through the actor

  # LangGraph visualization with actors
  Scenario: Visualize actor-based LangGraph
    Given I have a complex LangGraph with multiple actors:
      """
      {
        "name": "visualization_graph",
        "nodes": {
          "input": {
            "type": "input",
            "actor": "openai/gpt-3.5-turbo"
          },
          "process": {
            "type": "llm",
            "actor": "anthropic/claude-3"
          },
          "validate": {
            "type": "tool",
            "actor": "local/validator"
          },
          "output": {
            "type": "output",
            "actor": "openai/gpt-4"
          }
        },
        "edges": [
          {"source": "input", "target": "process"},
          {"source": "process", "target": "validate"},
          {"source": "validate", "target": "output"}
        ]
      }
      """
    When I visualize the graph
    Then the visualization should show all nodes with their actors
    And the edge flow should be clearly represented
    And actor transitions should be highlighted

  # Agent factory with default actor
  Scenario: Agent factory creates agents with default actor
    Given I have an agent factory with default actor "openai/gpt-4"
    When I create multiple agents using the factory:
      | agent_name | agent_type |
      | parser     | chain      |
      | analyzer   | tool       |
      | generator  | composite  |
    Then all agents should use the default actor "openai/gpt-4"
    And each agent should have the correct type

  # LangGraph with conditional routing based on actor capabilities
  Scenario: Conditional routing based on actor capabilities
    Given I have a LangGraph with conditional routing:
      """
      {
        "name": "capability_router",
        "nodes": {
          "router": {
            "type": "conditional",
            "conditions": [
              {
                "if": "needs_vision",
                "then": "vision_processor",
                "actor": "openai/gpt-4-vision"
              },
              {
                "if": "needs_code",
                "then": "code_generator",
                "actor": "anthropic/claude-3-opus"
              },
              {
                "else": "general_processor",
                "actor": "openai/gpt-3.5-turbo"
              }
            ]
          }
        }
      }
      """
    When I route a request that needs vision
    Then the request should be routed to "openai/gpt-4-vision"
    And the routing decision should be based on actor capabilities