go-http-session-observability

Answer

GAP-009 root cause: sessionEntry held only SessionID/Status/StartedAt/LastActive/TurnCount. GET /v1/sessions/{id} therefore had nothing to map into current_decision_id/current_decision_type (both always absent), and POST /v1/cancel had no source for the in-flight decision id, so it hardcoded cancelled_decision_id:"".

Fix: two new state fields on sessionEntry; processHandler/resultHandler persist the FINALIZED decision (using the auto-generated DecisionID) through a single write path s.sessions.update; cancelHandler reads the entry's in-flight id; getSessionHandler maps the entry 1:1 into SessionResponse.

1. State + store (harness.go):

type sessionEntry struct {
    SessionID           string
    Status              string
    StartedAt           time.Time
    LastActive          time.Time
    TurnCount           int
    // GAP-009: current-decision observability state.
    CurrentDecisionID   string
    CurrentDecisionType string
}

type sessionStore struct {
    mu      sync.RWMutex
    entries map[string]*sessionEntry
}

// get returns an immutable snapshot; callers compute the next state from it
// but never mutate it. update is the ONLY write path and swaps atomically.
func (s *sessionStore) get(id string) (*sessionEntry, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    e, ok := s.entries[id]
    if !ok {
        return nil, false
    }
    cp := *e // all value fields -> shallow copy is a full snapshot
    return &cp, true
}

// update persists the full entry (identity + mutable state). This is where
// FINALIZED decision state lands for process/result; unknown ids are inserted.
func (s *sessionStore) update(e *sessionEntry) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.entries[e.SessionID] = e
}

// newDecisionID auto-generates the DecisionID, so the id returned at process
// time is exactly the one observable via get/cancel afterwards.
func newDecisionID(sessionID string, turn int) string {
    return fmt.Sprintf("decision_%s_t%d", sessionID, turn)
}

2. processHandler — persist the FINALIZED decision (via s.sessions.update):

func (h *harness) processHandler(w http.ResponseWriter, r *http.Request) {
    var req processRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.SessionID == "" {
        writeErr(w, http.StatusBadRequest, "invalid process request")
        return
    }
    base, ok := h.sessions.get(req.SessionID)
    e := &sessionEntry{SessionID: req.SessionID, StartedAt: time.Now().UTC()}
    turn := 1
    if ok {
        e.StartedAt = base.StartedAt
        turn = base.TurnCount + 1
        e.CurrentDecisionType = base.CurrentDecisionType
    }
    e.TurnCount = turn
    e.Status = "processing"
    e.LastActive = time.Now().UTC()
    e.CurrentDecisionID = newDecisionID(e.SessionID, e.TurnCount) // auto-generated
    if req.DecisionType != "" {
        e.CurrentDecisionType = req.DecisionType
    }
    h.sessions.update(e) // GAP-009: FINALIZED decision persisted
    writeJSON(w, http.StatusOK, map[string]string{
        "session_id":  e.SessionID,
        "decision_id": e.CurrentDecisionID,
        "status":      e.Status,
    })
}

3. resultHandler — finalize, reusing the auto-generated id when the client omits one (same s.sessions.update path):

    base, ok := h.sessions.get(req.SessionID)
    if !ok {
        writeErr(w, http.StatusNotFound, "session not found")
        return
    }
    e := &sessionEntry{
        SessionID:           base.SessionID,
        Status:              "completed",
        StartedAt:           base.StartedAt,
        LastActive:          time.Now().UTC(),
        TurnCount:           base.TurnCount,
        CurrentDecisionID:   base.CurrentDecisionID,
        CurrentDecisionType: base.CurrentDecisionType,
    }
    if e.CurrentDecisionID == "" {
        e.CurrentDecisionID = newDecisionID(e.SessionID, e.TurnCount+1)
    }
    if req.DecisionID != "" {
        e.CurrentDecisionID = req.DecisionID
    }
    if req.DecisionType != "" {
        e.CurrentDecisionType = req.DecisionType
    }
    h.sessions.update(e)

4. cancelHandler — return the entry's in-flight id (empty only when nothing finalized):

func (h *harness) cancelHandler(w http.ResponseWriter, r *http.Request) {
    var req cancelRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        writeErr(w, http.StatusBadRequest, "invalid cancel request")
        return
    }
    cancelled := ""
    if e, ok := h.sessions.get(req.SessionID); ok {
        cancelled = e.CurrentDecisionID // in-flight/finalized id; "" only pre-finalization
    }
    writeJSON(w, http.StatusOK, CancelResponse{CancelledDecisionID: cancelled})
}

5. getSessionHandler — map entry into SessionResponse (the CurrentDecision* fields are the GAP-009 addition; omitempty keeps pre-finalization sessions and old clients clean):

type SessionResponse struct {
    SessionID           string    `json:"session_id"`
    Status              string    `json:"status"`
    StartedAt           time.Time `json:"started_at"`
    LastActive          time.Time `json:"last_active"`
    TurnCount           int       `json:"turn_count"`
    CurrentDecisionID   string    `json:"current_decision_id,omitempty"`
    CurrentDecisionType string    `json:"current_decision_type,omitempty"`
}

func (h *harness) getSessionHandler(w http.ResponseWriter, r *http.Request) {
    id := strings.TrimPrefix(r.URL.Path, "/v1/sessions/")
    e, ok := h.sessions.get(id)
    if !ok {
        writeErr(w, http.StatusNotFound, "session not found")
        return
    }
    writeJSON(w, http.StatusOK, SessionResponse{
        SessionID:           e.SessionID,
        Status:              e.Status,
        StartedAt:           e.StartedAt,
        LastActive:          e.LastActive,
        TurnCount:           e.TurnCount,
        CurrentDecisionID:   e.CurrentDecisionID,
        CurrentDecisionType: e.CurrentDecisionType,
    })
}

Blast radius: all changes are confined to harness.go (state struct + store + 4 handlers). sessionStore is only exercised by harness_test.go; the SDK client package is untouched. Routes: POST /v1/process, POST /v1/result, POST /v1/cancel, GET /v1/sessions/{id} (Go 1.22+ method+pattern mux).