Method Dispatch

pkg/hooks/executor.go:170–228

Dispatch runs the hooks registered for event and aggregates their verdicts into a single [Result]. Sets input.HookEventName so handlers don't have to remember. Defaults [Input.Cwd] to the executor's working directory when the caller didn't supply one. EventPreToolUsePreYolo is an internal sentinel

(ctx context.Context, event EventType, input *Input)

// handlers) and aggregation reuses the EventPreToolUse branches.
// Tracing keeps the lane visible via the span name.
func (e *Executor) Dispatch(ctx context.Context, event EventType, input *Input) (*Result, error) {
	hooks := e.hooksFor(event, input.ToolName)
	if len(hooks) == 0 {
		return &Result{Allowed: true}, nil
	}

	// Hooks on the preempt-yolo lane see the public pre_tool_use event
	// name so a single handler implementation works on either lane.
	publicEvent := event
	if event == EventPreToolUsePreYolo {
		publicEvent = EventPreToolUse
	}

	// Single span per Dispatch call covers every hook the event matched.
	// Custom name `hook.{event}` because there is no GenAI semconv for
	// arbitrary user-defined lifecycle hooks; we surface the event type,
	// matched hook count, and session/agent identifiers so dashboards can
	// split by event class without parsing span events.
	ctx, span := otel.Tracer("github.com/docker/docker-agent/pkg/hooks").Start(
		ctx,
		"hook."+string(event),
		trace.WithSpanKind(trace.SpanKindInternal),
		trace.WithAttributes(
			attribute.String("cagent.hook.event", string(event)),
			attribute.Int("cagent.hook.count", len(hooks)),
			attribute.String("cagent.agent.name", input.AgentName),
			attribute.String("gen_ai.conversation.id", input.SessionID),
		),
	)
	if input.ToolName != "" {
		span.SetAttributes(attribute.String("gen_ai.tool.name", input.ToolName))
	}
	defer span.End()

	input.HookEventName = publicEvent
	if input.Cwd == "" {
		input.Cwd = e.workingDir
	}

	slog.DebugContext(ctx, "Executing hooks", "event", event, "session_id", input.SessionID, "count", len(hooks))

	inputJSON, err := input.ToJSON()
	if err != nil {
		span.RecordError(err)
		span.SetStatus(codes.Error, err.Error())
		return nil, fmt.Errorf("failed to serialize hook input: %w", err)
	}

	results := make([]hookResult, len(hooks))
	var wg sync.WaitGroup
	for i, hook := range hooks {
		wg.Go(func() { results[i] = e.runHook(ctx, hook, inputJSON) })
	}
	wg.Wait()

	final := aggregate(results, event)
	annotateHookSpan(span, event, final)
	return final, nil