tutti/packages/agent/daemon/runtime/report_log_summary.go

package agentruntime

import (
	"fmt"
	"sort"
	"strings"

	agentsessionstore "github.com/tutti-os/tutti/packages/agent/daemon/activity"
	"github.com/tutti-os/tutti/packages/agent/store-sqlite/canonical"
)

const (
	maxReportLogMessageUpdates   = 8
	maxReportLogStatePatches     = 6
	maxReportLogEntitiesPerPatch = 3
	maxReportLogSummaryLength    = 600
	maxReportLogErrorLength      = 360
)

func SummarizeReportActivityInputForLog(
	input agentsessionstore.ReportActivityInput,
) ([]string, []string) {
	messageUpdates := summarizeMessageUpdatesForLog(input.MessageUpdates)
	statePatches := summarizeStatePatchesForLog(input.StatePatches)
	return messageUpdates, statePatches
}

func summarizeMessageUpdatesForLog(updates []agentsessionstore.WorkspaceAgentMessageUpdate) []string {
	if len(updates) == 0 {
		return nil
	}
	limit := minReportLogInt(len(updates), maxReportLogMessageUpdates)
	out := make([]string, 0, limit+1)
	for _, update := range updates[:limit] {
		bodyKinds := summarizeBodyKinds(
			payloadHasNonEmptyField(update.Payload, "input"),
			payloadHasNonEmptyField(update.Payload, "output"),
			payloadHasNonEmptyField(update.Payload, "error"),
			payloadHasNonEmptyField(update.Payload, "text"),
		)
		summary := fmt.Sprintf(
			"%s|%s|%s|call=%s|turn=%s|body=%s|name=%s",
			logSummaryValue(update.MessageID),
			logSummaryValue(update.Kind),
			logSummaryValue(update.Status),
			logSummaryValue(update.CallID),
			logSummaryValue(update.TurnID),
			bodyKinds,
			logSummaryValue(messageUpdateNameForLog(update)),
		)
		if shouldLogMessageUpdateError(update) {
			if errorSummary := messageUpdateErrorSummaryForLog(update.Payload); errorSummary != "" {
				summary += fmt.Sprintf("|error=%q", errorSummary)
			}
		}
		out = append(out, trimReportLogSummary(summary))
	}
	if len(updates) > limit {
		out = append(out, fmt.Sprintf("...+%d more message updates", len(updates)-limit))
	}
	return out
}

func summarizeStatePatchesForLog(patches []agentsessionstore.WorkspaceAgentStatePatch) []string {
	if len(patches) == 0 {
		return nil
	}
	limit := minReportLogInt(len(patches), maxReportLogStatePatches)
	out := make([]string, 0, limit+1)
	for _, patch := range patches[:limit] {
		entityLimit := minReportLogInt(len(patch.Entities), maxReportLogEntitiesPerPatch)
		entitySummaries := make([]string, 0, entityLimit+1)
		for _, entity := range patch.Entities[:entityLimit] {
			entitySummaries = append(entitySummaries, trimReportLogSummary(fmt.Sprintf(
				"%s|%s|call=%s|turn=%s|body=%s|done=%t",
				logSummaryValue(firstNonEmpty(entity.Name, entity.CallType)),
				logSummaryValue(entity.Status),
				logSummaryValue(entity.CallID),
				logSummaryValue(entity.TurnID),
				summarizeBodyKinds(
					len(entity.Input) > 0,
					len(entity.Output) > 0,
					len(entity.Error) > 0,
					false,
				),
				entity.CompletedAtUnixMS > 0,
			)))
		}
		if len(patch.Entities) > entityLimit {
			entitySummaries = append(entitySummaries, fmt.Sprintf("...+%d more entities", len(patch.Entities)-entityLimit))
		}
		out = append(out, trimReportLogSummary(fmt.Sprintf(
			"session=%s|phase=%s|lifecycle=%s|turn=%s|turnLifecycle=%s|rootProviderTurn=%s|entities=%s",
			logSummaryValue(patch.AgentSessionID),
			logSummaryValue(patch.CurrentPhase),
			logSummaryValue(patch.LifecycleStatus),
			logSummaryValue(turnPatchSummary(patch.Turn)),
			logSummaryValue(turnLifecycleSummary(patch.TurnLifecycle)),
			logSummaryValue(rootProviderTurnSummary(patch.RootProviderTurn)),
			strings.Join(entitySummaries, ";"),
		)))
	}
	if len(patches) > limit {
		out = append(out, fmt.Sprintf("...+%d more state patches", len(patches)-limit))
	}
	return out
}

func summarizeLogValueCounts(values []string) []string {
	if len(values) == 0 {
		return nil
	}
	counts := make(map[string]int, len(values))
	order := make([]string, 0, len(values))
	for _, value := range values {
		value = strings.TrimSpace(value)
		if value == "" {
			continue
		}
		if counts[value] == 0 {
			order = append(order, value)
		}
		counts[value]++
	}
	if len(order) == 0 {
		return nil
	}
	out := make([]string, 0, len(order))
	for _, value := range order {
		out = append(out, fmt.Sprintf("%s=%d", value, counts[value]))
	}
	return out
}

func payloadHasNonEmptyField(payload map[string]any, key string) bool {
	if len(payload) == 0 {
		return false
	}
	value, ok := payload[key]
	if !ok {
		return false
	}
	return !payloadValueIsEmpty(value)
}

func messageUpdateNameForLog(update agentsessionstore.WorkspaceAgentMessageUpdate) string {
	return firstNonEmpty(
		payloadStringValueForLog(update.Payload, "toolName"),
		payloadStringValueForLog(update.Payload, "name"),
		update.Title,
	)
}

func shouldLogMessageUpdateError(update agentsessionstore.WorkspaceAgentMessageUpdate) bool {
	if !messageUpdateIsCallForLog(update) {
		return false
	}
	status := strings.ToLower(strings.TrimSpace(update.Status))
	if status == "failed" || status == "failure" || status == "error" || status == "errored" {
		return true
	}
	kind := strings.ToLower(strings.TrimSpace(update.Kind))
	return kind == "call.failed" || kind == "call.errored"
}

func messageUpdateIsCallForLog(update agentsessionstore.WorkspaceAgentMessageUpdate) bool {
	kind := strings.ToLower(strings.TrimSpace(update.Kind))
	if kind == "tool_call" || strings.HasPrefix(kind, "call.") {
		return true
	}
	return strings.TrimSpace(update.CallID) != ""
}

func messageUpdateErrorSummaryForLog(payload map[string]any) string {
	for _, candidate := range []any{
		payloadFieldValueForLog(payload, "error", "message"),
		payloadFieldValueForLog(payload, "error", "stderr"),
		payloadFieldValueForLog(payload, "error", "reason"),
		payloadFieldValueForLog(payload, "error", "output"),
		payloadFieldValueForLog(payload, "error", "aggregated_output"),
		payloadFieldValueForLog(payload, "error", "text"),
		payloadValueForLog(payload, "error"),
		payloadFieldValueForLog(payload, "output", "stderr"),
		payloadFieldValueForLog(payload, "output", "aggregated_output"),
		payloadFieldValueForLog(payload, "output", "output"),
	} {
		if summary := summarizePayloadValueForLog(candidate, maxReportLogErrorLength); summary != "" {
			return summary
		}
	}
	return ""
}

func payloadStringValueForLog(payload map[string]any, key string) string {
	value := payloadValueForLog(payload, key)
	switch typed := value.(type) {
	case string:
		return typed
	default:
		return ""
	}
}

func payloadValueForLog(payload map[string]any, key string) any {
	if len(payload) == 0 {
		return nil
	}
	return payload[key]
}

func payloadFieldValueForLog(payload map[string]any, key string, field string) any {
	value := payloadValueForLog(payload, key)
	object, ok := value.(map[string]any)
	if !ok {
		return nil
	}
	return object[field]
}

func summarizePayloadValueForLog(value any, limit int) string {
	if payloadValueIsEmpty(value) {
		return ""
	}
	var summary string
	switch typed := value.(type) {
	case string:
		summary = typed
	case map[string]any:
		summary = summarizePayloadMapForLog(typed)
	default:
		summary = fmt.Sprint(typed)
	}
	summary = strings.Join(strings.Fields(summary), " ")
	return trimReportLogSummaryToLength(summary, limit)
}

func summarizePayloadMapForLog(payload map[string]any) string {
	if len(payload) == 0 {
		return ""
	}
	keys := make([]string, 0, len(payload))
	for key := range payload {
		keys = append(keys, key)
	}
	sort.Strings(keys)
	parts := make([]string, 0, len(keys))
	for _, key := range keys {
		value := summarizePayloadValueForLog(payload[key], maxReportLogErrorLength)
		if value == "" {
			continue
		}
		parts = append(parts, fmt.Sprintf("%s=%s", key, value))
	}
	return strings.Join(parts, " ")
}

func summarizeBodyKinds(hasInput, hasOutput, hasError, hasText bool) string {
	kinds := make([]string, 0, 4)
	if hasInput {
		kinds = append(kinds, "input")
	}
	if hasOutput {
		kinds = append(kinds, "output")
	}
	if hasError {
		kinds = append(kinds, "error")
	}
	if hasText {
		kinds = append(kinds, "text")
	}
	if len(kinds) == 0 {
		return "-"
	}
	return strings.Join(kinds, "+")
}

func turnPatchSummary(turn *agentsessionstore.WorkspaceAgentTurnPatch) string {
	if turn == nil {
		return ""
	}
	parts := []string{logSummaryValue(turn.TurnID)}
	if phase := logSummaryValue(turn.Phase); phase != "-" {
		parts = append(parts, phase)
	}
	if outcome := logSummaryValue(turn.Outcome); outcome != "-" {
		parts = append(parts, outcome)
	}
	return strings.Join(parts, "/")
}

func turnLifecycleSummary(lifecycle *canonical.WorkspaceAgentTurnLifecycle) string {
	if lifecycle == nil {
		return ""
	}
	activeTurnID := ""
	if lifecycle.ActiveTurnID != nil {
		activeTurnID = *lifecycle.ActiveTurnID
	}
	parts := []string{logSummaryValue(activeTurnID), logSummaryValue(lifecycle.Phase)}
	if lifecycle.Outcome != nil {
		if outcome := logSummaryValue(*lifecycle.Outcome); outcome != "-" {
			parts = append(parts, outcome)
		}
	}
	return strings.Join(parts, "/")
}

func rootProviderTurnSummary(turn *canonical.WorkspaceAgentRootProviderTurnTransition) string {
	if turn == nil {
		return ""
	}
	parts := []string{
		logSummaryValue(turn.RootTurnID),
		logSummaryValue(turn.ProviderTurnID),
		logSummaryValue(turn.Phase),
	}
	if outcome := logSummaryValue(turn.Outcome); outcome != "-" {
		parts = append(parts, outcome)
	}
	return strings.Join(parts, "/")
}

func logSummaryValue(value string) string {
	trimmed := strings.TrimSpace(value)
	if trimmed == "" {
		return "-"
	}
	return trimReportLogSummary(trimmed)
}

func trimReportLogSummary(value string) string {
	return trimReportLogSummaryToLength(value, maxReportLogSummaryLength)
}

func trimReportLogSummaryToLength(value string, limit int) string {
	trimmed := strings.TrimSpace(value)
	if limit <= 3 {
		return trimmed
	}
	if len(trimmed) <= limit {
		return trimmed
	}
	return trimmed[:limit-3] + "..."
}

func minReportLogInt(left, right int) int {
	if left < right {
		return left
	}
	return right
}