action-executor.ts

import type { RuntimeEventBus } from "../events/runtime-events.js";
import { assertMaxToolCalls } from "../guards/runtime-guards.js";
import type { RuntimeLogger } from "../logger/runtime-logger.js";
import type { RuntimeContext } from "../runtime/context.js";
import { ToolRegistry } from "../tools/tool-registry.js";

function resolveAgentId(
  agent: { agentId?: string; id?: string } | undefined
): string {
  return agent?.agentId ?? agent?.id ?? "";
}

export class ActionExecutor {
  private readonly toolCallCounts = new Map<string, number>();
  private readonly logger: RuntimeLogger | undefined;
  private readonly eventBus: RuntimeEventBus | undefined;
  private readonly maxToolCallsPerTask: number | undefined;
  private readonly maxTrackedTasks: number;

  public constructor(
    private readonly toolRegistry: ToolRegistry,
    maxToolCallsPerTaskOrLogger?: number | RuntimeLogger,
    eventBus?: RuntimeEventBus,
    maxTrackedTasks = 1_000
  ) {
    if (!Number.isInteger(maxTrackedTasks) || maxTrackedTasks < 1) {
      throw new RangeError("maxTrackedTasks must be a positive integer.");
    }

    if (typeof maxToolCallsPerTaskOrLogger === "number") {
      this.maxToolCallsPerTask = maxToolCallsPerTaskOrLogger;
      if (
        eventBusOrLogger !== undefined &&
        "emit" in eventBusOrLogger &&
        typeof eventBusOrLogger.emit === "function"
      ) {
        this.eventBus = eventBusOrLogger;
        this.logger = logger;
      } else {
        this.eventBus = undefined;
        this.logger = (eventBusOrLogger as RuntimeLogger | undefined) ?? logger;
      }
    } else if (
      maxToolCallsPerTaskOrLogger !== undefined &&
      typeof maxToolCallsPerTaskOrLogger === "object" &&
      ("info" in maxToolCallsPerTaskOrLogger ||
        "warn" in maxToolCallsPerTaskOrLogger ||
        "debug" in maxToolCallsPerTaskOrLogger ||
        "error" in maxToolCallsPerTaskOrLogger)
    ) {
      this.maxToolCallsPerTask = undefined;
      this.logger = maxToolCallsPerTaskOrLogger;
      if (
        eventBusOrLogger !== undefined &&
        "emit" in eventBusOrLogger &&
        typeof eventBusOrLogger.emit === "function"
      ) {
        this.eventBus = eventBusOrLogger;
      } else {
        this.eventBus = undefined;
      }
    } else {
      this.maxToolCallsPerTask = undefined;
      if (
        eventBusOrLogger !== undefined &&
        "emit" in eventBusOrLogger &&
        typeof eventBusOrLogger.emit === "function"
      ) {
        this.eventBus = eventBusOrLogger;
        this.logger = logger;
      } else {
        this.eventBus = undefined;
        this.logger = (eventBusOrLogger as RuntimeLogger | undefined) ?? logger;
      }
    }
    this.eventBus = eventBus;
    this.maxTrackedTasks = maxTrackedTasks;
  }

  public getToolCallCount(taskId: string): number {
    return this.toolCallCounts.get(taskId) ?? 0;
  }

  /** Clears the retained call budget for one completed task. */
  public reset(taskId: string): void {
    this.toolCallCounts.delete(taskId);
  }

  /** Clears all retained per-task call budgets. */
  public resetAll(): void {
    this.toolCallCounts.clear();
  }

  public async execute<TPayload, TResult>(
    toolName: string,
    payload: TPayload,
    context: RuntimeContext
  ): Promise<TResult> {
    const tool = this.toolRegistry.get(toolName);

    const currentCount = this.getToolCallCount(context.taskId);
    if (this.maxToolCallsPerTask !== undefined) {
      assertMaxToolCalls(currentCount, this.maxToolCallsPerTask);
    }

    const tool = this.toolRegistry.get(toolName);

    this.toolCallCounts.set(context.taskId, currentCount + 1);

    const startedAt = Date.now();

    this.eventBus?.emit({
      name: "runtime.tool.invoked",
      payload: {
        runtimeId: context.runtimeId,
        taskId: context.taskId,
        agentId: resolveAgentId(context.agent),
        toolName,
      },
    });

    try {
      const result = await tool.execute(payload, context);
      const duration = Date.now() - startedAt;

      this.eventBus?.emit({
        name: "runtime.tool.success",
        payload: {
          runtimeId: context.runtimeId,
          taskId: context.taskId,
          agentId: resolveAgentId(context.agent),
          toolName,
          duration,
        },
      });

      return result;
    } catch (error) {
      const duration = Date.now() - startedAt;

      this.eventBus?.emit({
        name: "runtime.tool.error",
        payload: {
          runtimeId: context.runtimeId,
          taskId: context.taskId,
          agentId: resolveAgentId(context.agent),
          toolName,
          duration,
          error,
        },
      });

      throw error;
    }
  }
}