fix: cap query tool results to prevent token limit errors

A single tool result could be 647KB (20 rows with full log body examples).
This gets stored in conversation history and sent with every API call,
eventually hitting the 200K token limit.

- Truncate any string field > 4KB with '…(truncated)'
- Drop trailing rows if total serialized JSON > 100KB
- Include rows_dropped count in result so the AI knows data was omitted

Author: binarylogic

internal/app/chat/messagelist/round/turn/assistant/blocks/tools/query/query.go

@@ -41,9 +41,10 @@ type Model struct {
 	resultTemplate string
 
 	// Results
-	rows     []map[string]any
-	err      error
-	duration time.Duration
+	rows        []map[string]any
+	rowsDropped int
+	err         error
+	duration    time.Duration
 }
 
 // New creates a new query tool model.
@@ -215,16 +216,17 @@ func (m *Model) execute() tea.Cmd {
 	}
 
 	m.rows = result.Rows
+	m.rowsDropped = result.RowsDropped
 	m.state = tools.StateComplete
-	m.scope.Info("query completed", "row_count", len(m.rows), "duration", m.duration)
+	m.scope.Info("query completed", "row_count", len(m.rows), "rows_dropped", m.rowsDropped, "duration", m.duration)
 	return m.fireCompleted()
 }
 
 func (m *Model) fireCompleted() tea.Cmd {
 	return func() tea.Msg {
 		return msgs.QueryCompleted{
 			ToolUseID: m.toolID,
-			Result:    domaintools.QueryResult{Rows: m.rows},
+			Result:    domaintools.QueryResult{Rows: m.rows, RowsDropped: m.rowsDropped},
 			Error:     m.err,
 		}
 	}

internal/chat/tools/query.go

@@ -109,5 +109,46 @@ func (t *QueryTool) Execute(input json.RawMessage) (tools.QueryResult, error) {
 	if err := rows.Err(); err != nil {
 		return tools.QueryResult{}, err
 	}
-	return tools.QueryResult{Rows: results}, nil
+
+	capped, dropped := capResults(results)
+	return tools.QueryResult{Rows: capped, RowsDropped: dropped}, nil
+}
+
+const (
+	maxFieldBytes  = 4096   // truncate any string value longer than this
+	maxResultBytes = 102400 // drop trailing rows if total JSON exceeds this
+)
+
+// capResults truncates large string values and drops trailing rows to keep
+// the serialized result within size limits. Returns the capped rows and the
+// number of rows that were dropped.
+func capResults(rows []map[string]any) ([]map[string]any, int) {
+	for _, row := range rows {
+		for k, v := range row {
+			s, ok := v.(string)
+			if ok && len(s) > maxFieldBytes {
+				row[k] = s[:maxFieldBytes] + "…(truncated)"
+			}
+		}
+	}
+
+	b, err := json.Marshal(rows)
+	if err != nil || len(b) <= maxResultBytes {
+		return rows, 0
+	}
+
+	// Binary search for the max number of rows that fit.
+	total := len(rows)
+	lo, hi := 0, total
+	for lo < hi {
+		mid := (lo + hi + 1) / 2
+		b, _ = json.Marshal(rows[:mid])
+		if len(b) <= maxResultBytes {
+			lo = mid
+		} else {
+			hi = mid - 1
+		}
+	}
+
+	return rows[:lo], total - lo
 }

internal/domain/tools/query.go

@@ -9,10 +9,15 @@ type QueryInput struct {
 
 // QueryResult is the typed output of a query tool execution.
 type QueryResult struct {
-	Rows []map[string]any `json:"rows"`
+	Rows        []map[string]any `json:"rows"`
+	RowsDropped int              `json:"rows_dropped,omitempty"`
 }
 
 // ToMap serializes the result for the GraphQL API.
 func (r QueryResult) ToMap() map[string]any {
-	return map[string]any{"rows": r.Rows}
+	m := map[string]any{"rows": r.Rows}
+	if r.RowsDropped > 0 {
+		m["rows_dropped"] = r.RowsDropped
+	}
+	return m
 }