go-chat-structured-filters-time-range

Answer

Root cause. handleChat translated the NL message into a fully-populated types.SearchRequest, then collapsed it to SearchFlows(sr.Query, sr.Limit) — silently dropping TimeRange, Categories, and Outcomes. A time-only question ("flows from the last hour") produced an empty query with a real window, and the window never reached the store. The fix was wiring, not reimplementation: grep showed all the primitives already existed — types.SearchRequest carried the filters, store.QueryFlows already filtered by phase/outcome/start_time window (mirrored in handleSearch), and parseTranslateResponse already parsed phases/outcomes. Three small changes:

1. Route chat through QueryFlows, threading every filter (chat/handler.go):

// Before (bug): dropped TimeRange/Categories/Outcomes
sr, _ := h.trans.Translate(ctx, message)
return h.store.SearchFlows(sr.Query, sr.Limit)   // ← filters lost

// After (fix): the one-line wiring change
func (h *Handler) HandleChat(ctx context.Context, message string) ([]store.Flow, error) {
    sr, err := h.trans.Translate(ctx, message)
    if err != nil {
        return nil, err
    }
    return h.store.QueryFlows(sr.Query, sr.Limit, sr.TimeRange, sr.Categories, sr.Outcomes), nil
}

SearchFlows stays as a thin legacy wrapper (return s.QueryFlows(query, limit, nil, nil, nil)) for old call sites; chat no longer uses it. The pre-existing handleSearch path was already correct and is now the shared route.

2. Extend translateSystemPrompt to emit time_range + inject current UTC time (chat/translate.go) — relative windows ("last hour") need a concrete anchor, otherwise the model guesses "now" and the window is wrong:

func translateSystemPrompt(now time.Time) string {
    return fmt.Sprintf(`You translate a chat message into a structured search request.
Current time: %s (UTC).

Respond with JSON only:
{"query": string, "categories": [string], "outcomes": [string],
 "time_range": {"start": string|null, "end": string|null}}

Rules:
- query: free-text terms, or "" when the message only expresses filters.
- categories: flow phases to include; [] when unspecified.
- outcomes: flow outcomes to include; [] when unspecified.
- time_range: RFC3339 UTC timestamps; interpret relative windows
  ("last hour", "past 30 days") against the current time above.
  Use null for an open bound ("before 2024-01-01" ->
  {"start": null, "end": "2024-01-01T00:00:00Z"}). Use null/null when no
  time constraint is expressed.`, now.UTC().Format(time.RFC3339))
}

3. parseTranslateResponse parses the nullable RFC3339 window; query=="" is rejected only when no window is present:

type timeRangeWire struct {
    Start *time.Time `json:"start"`
    End   *time.Time `json:"end"`
}

type translateWire struct {
    Query      string         `json:"query"`
    Categories []string       `json:"categories"`
    Outcomes   []string       `json:"outcomes"`
    TimeRange  *timeRangeWire `json:"time_range"`
}

func parseTranslateResponse(raw string) (types.SearchRequest, error) {
    var w translateWire
    if err := json.Unmarshal([]byte(raw), &w); err != nil {
        return types.SearchRequest{}, fmt.Errorf("parse translate response: %w", err)
    }
    req := types.SearchRequest{Query: strings.TrimSpace(w.Query), Categories: w.Categories, Outcomes: w.Outcomes}
    if w.TimeRange != nil {
        tr := &types.TimeRange{Start: w.TimeRange.Start, End: w.TimeRange.End}
        if tr.Start != nil || tr.End != nil { // normalize null/null → no window
            req.TimeRange = tr
        }
    }
    // A pure time-range question legitimately has query=="" — only reject
    // when there is no window either.
    if req.Query == "" && req.TimeRange == nil {
        return types.SearchRequest{}, errors.New("empty query with no time range")
    }
    return req, nil
}

Pattern: before reimplementing any search/filter primitive, grep for the existing structured query paths (QueryFlows, handleSearch, SearchRequest fields) and wire into them.