cleveractors-core/features/steps/runtime_config_steps.py

"""Step definitions for Runtime Executor config setup (Given steps).

Extracted from runtime_coverage_steps.py to stay under the 500-line
file limit (CONTRIBUTING.md General Principles).
"""

from __future__ import annotations

from typing import Any

from behave import given

# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------


def _build_base_config(type_name: str) -> dict[str, Any]:
    return {
        "name": f"test_{type_name}",
        "type": type_name,
    }


# ---------------------------------------------------------------------------
# Given — environment and configuration
# ---------------------------------------------------------------------------


@given("the runtime test environment is initialized")
def step_runtime_init(context: Any) -> None:
    context.test_executor = None
    context.test_result = None
    context.test_error = None


@given('a valid actor config dict with type "unknown_type"')
def step_config_unknown(context: Any) -> None:
    context.config_dict = _build_base_config("unknown_type")


@given('a valid actor config dict with type "llm"')
def step_config_llm_basic(context: Any) -> None:
    context.config_dict = _build_base_config("llm")
    context.config_dict.update(
        {
            "provider": "openai",
            "model": "gpt-3.5-turbo",
            "system_prompt": "You are a helpful assistant.",
            "temperature": 0.7,
            "max_tokens": 1000,
        }
    )


@given('a valid actor config dict with type "graph" and route definition')
def step_config_graph_route(context: Any) -> None:
    context.config_dict = _build_base_config("graph")
    context.config_dict["route"] = {
        "nodes": [
            {"id": "start", "type": "start"},
            {"id": "end", "type": "end"},
        ],
        "edges": [],
        "entry_node": "start",
        "exit_nodes": ["end"],
    }


@given('a valid actor config dict with type "graph" and empty route nodes')
def step_config_graph_empty_route(context: Any) -> None:
    context.config_dict = _build_base_config("graph")
    context.config_dict["route"] = {
        "nodes": [],
        "edges": [],
        "entry_node": "start",
    }


@given('a valid actor config dict with type "tool" and tools list')
def step_config_tool(context: Any) -> None:
    context.config_dict = _build_base_config("tool")
    context.config_dict["tools"] = ["echo"]
    context.config_dict["config"] = {"tools": ["echo"]}


@given('a valid actor config dict with type "llm" and openai provider')
def step_config_llm_openai(context: Any) -> None:
    context.config_dict = _build_base_config("llm")
    context.config_dict.update(
        {
            "provider": "openai",
            "model": "gpt-3.5-turbo",
            "system_prompt": "You are a helpful assistant.",
            "temperature": 0.7,
            "max_tokens": 1000,
        }
    )


@given('a valid actor config dict with type "graph" and full route definition')
def step_config_graph_full(context: Any) -> None:
    context.config_dict = _build_base_config("graph")
    context.config_dict["route"] = {
        "nodes": [
            {"id": "start", "type": "start"},
            {"id": "process", "type": "function", "function": "process_input"},
            {"id": "llm_node", "type": "llm", "agent": "test_agent"},
            {"id": "end", "type": "end"},
        ],
        "edges": [
            {"source": "start", "target": "process"},
            {"source": "process", "target": "llm_node"},
            {"source": "llm_node", "target": "end"},
        ],
        "entry_node": "start",
        "exit_nodes": ["end"],
    }
    context.config_dict["agents"] = {
        "test_agent": {"type": "llm", "config": {"provider": "openai"}},
    }


# ---------------------------------------------------------------------------
# Given — credentials, limits, pricing
# ---------------------------------------------------------------------------


@given("credentials dict with openai provider")
def step_creds_openai(context: Any) -> None:
    context.credentials = {
        "openai": {
            "api_key": "sk-test-key-12345",
            "base_url": "https://api.openai.com/v1",
        }
    }


@given("credentials dict with openai api key")
def step_creds_openai_key(context: Any) -> None:
    context.credentials = {"openai": {"api_key": "sk-test-executor-key"}}


@given("limits dict with max_depth {depth}")
def step_limits(context: Any, depth: str) -> None:
    context.limits = {"max_depth": int(depth)}


@given("pricing dict with per_token_cost {cost}")
def step_pricing(context: Any, cost: str) -> None:
    context.pricing = {"per_token_cost": float(cost)}


@given("a multi-actor config dict with multiple sub-actors")
def step_multi_actor_config(context: Any) -> None:
    context.config_dict = {
        "name": "test_multi_actor",
        "type": "multi_actor",
        "actors": {
            "default": {
                "type": "llm",
                "provider": "openai",
                "model": "gpt-3.5-turbo",
                "system_prompt": "You are helpful.",
                "temperature": 0.7,
                "max_tokens": 1000,
            },
            "secondary": {
                "type": "tool",
                "tools": ["echo"],
            },
        },
        "cleveragents": {"default_actor": "default"},
    }


@given("a multi-actor config dict with empty actors")
def step_multi_actor_empty(context: Any) -> None:
    context.config_dict = {
        "name": "test_empty_actors",
        "type": "multi_actor",
        "actors": {},
        "cleveragents": {"default_actor": "default"},
    }