Class LLMExecutor

src/harness/execution/llm_executor.py:112–1449

Executes LLM interactions with multi-step tool calling support. This class is the core execution engine for LLM-driven workflow steps. It manages the conversation with the LLM, handles tool calls (both standard and inline), executes submodules, and supports durable execution via tra

class LLMExecutor(TracingMixin, ShellUtilsMixin):
    """Executes LLM interactions with multi-step tool calling support.

    This class is the core execution engine for LLM-driven workflow steps.
    It manages the conversation with the LLM, handles tool calls (both
    standard and inline), executes submodules, and supports durable
    execution via tracing.

    Attributes:
        mcp_client: MCP client for tool invocation.
        llm_client: LLMClient for LLM completions (supports multiple providers via LiteLLM).
        tools: List of available tool definitions.
        usage_tracker: Dict for tracking token usage across steps.
        metrics_lock: Threading lock for thread-safe metrics updates.

    Inherited from TracingMixin:
        _trace_lock: Lock for thread-safe trace writing.
        _trace_writer: Optional writer for durable execution traces.
        _llm_replay_events: Events for replay mode.
        _replay_index: Current position in replay events.

    Example:
        executor = LLMExecutor(mcp_client, tools, llm_client, usage_tracker)
        output, tokens = executor.execute_llm_step(
            instruction="Analyze the code",
            prev_output="",
            step_id=1,
            args=effective_args,
            logger=logger,
            context=workflow_context,
        )
    """

    def __init__(
        self,
        mcp_client: MCPClient,
        tools: List[Dict[str, Any]],
        llm_client: LLMClient,
        usage_tracker: Dict[str, int],
    ) -> None:
        """Initialize the LLM executor.

        Args:
            mcp_client: MCP client for invoking tools.
            tools: List of tool definitions in OpenAI format.
            llm_client: LLMClient for chat completions (supports multiple providers).
            usage_tracker: Mutable dict for accumulating token usage.
        """
        self.mcp_client = mcp_client
        self.llm_client = llm_client
        self.tools = tools
        self.usage_tracker = usage_tracker
        self.metrics_lock = threading.Lock()

        # Reference to interpreter for submodule execution (set by Interpreter after init)
        self.interpreter: Optional[Any] = None

        # Initialize tracing state (required by TracingMixin)