chatdebug

func (*RecordingTransport) RoundTrip ¶

func (t *RecordingTransport) RoundTrip(req *http.Request) (*http.Response, error)

func (*Service) AggregateRunSummary ¶

func (s *Service) AggregateRunSummary(
	ctx context.Context,
	runID uuid.UUID,
	baseSummary map[string]any,
) (map[string]any, error)

AggregateRunSummary reads all steps for the given run, computes token totals, and merges them with the run's existing summary (preserving any seeded first_message label). The baseSummary parameter should be the current run summary (may be nil).

func (*Service) CreateRun ¶

func (s *Service) CreateRun(
	ctx context.Context,
	params CreateRunParams,
) (database.ChatDebugRun, error)

CreateRun inserts a new debug run and emits a run update event.

func (*Service) CreateStep ¶

func (s *Service) CreateStep(
	ctx context.Context,
	params CreateStepParams,
) (database.ChatDebugStep, error)

CreateStep inserts a new debug step and emits a step update event. It returns errRunFinalized if the parent run has already finished, or errRunNotFound if the run_id/chat_id pair does not match an existing run. The finalization guard is enforced atomically by the INSERT's CTE, which issues an UPDATE on the parent run (taking a row lock). This prevents concurrent FinalizeStale from setting finished_at between the check and the INSERT.

func (*Service) DeleteAfterMessageID ¶

func (s *Service) DeleteAfterMessageID(
	ctx context.Context,
	chatID uuid.UUID,
	messageID int64,
	startedBefore time.Time,
) (int64, error)

DeleteAfterMessageID deletes debug data newer than the given message. The startedBefore bound scopes deletion to runs created before that instant so that retried cleanup does not remove runs created by a replacement turn that raced ahead of the retry window.

func (*Service) DeleteByChatID ¶

func (s *Service) DeleteByChatID(
	ctx context.Context,
	chatID uuid.UUID,
	startedBefore time.Time,
) (int64, error)

DeleteByChatID deletes debug data for a chat and emits a delete event. The startedBefore bound scopes deletion to runs created before that instant so that retried cleanup does not remove runs created by a replacement turn that raced ahead of the retry window (for example, an unarchive that fires between the initial archive-cleanup attempt and its retry).

func (*Service) FinalizeRun ¶

func (s *Service) FinalizeRun(ctx context.Context, p FinalizeRunParams) error

FinalizeRun aggregates the run summary, updates the run status, and cleans up the step counter. It detaches from the parent context's cancellation so finalization succeeds even when the request context is already done. Errors are returned but are always safe to ignore; callers that treat debug instrumentation as best-effort can discard them.

func (*Service) FinalizeStale ¶

func (s *Service) FinalizeStale(
	ctx context.Context,
) (database.FinalizeStaleChatDebugRowsRow, error)

FinalizeStale finalizes stale in-flight debug rows and emits a broadcast.

func (*Service) IsEnabled ¶

func (s *Service) IsEnabled(
	ctx context.Context,
	chatID uuid.UUID,
	ownerID uuid.UUID,
) bool

IsEnabled returns whether debug logging is enabled for the given chat.

func (*Service) SetStaleAfter ¶

func (s *Service) SetStaleAfter(staleAfter time.Duration)

SetStaleAfter overrides the in-flight stale threshold used when finalizing abandoned debug rows. Zero or negative durations are ignored, leaving the current threshold (initial or previously overridden) unchanged. Active heartbeat goroutines are woken so they can re-read the (possibly shorter) interval immediately.

func (*Service) TouchStep ¶

func (s *Service) TouchStep(
	ctx context.Context,
	stepID uuid.UUID,
	runID uuid.UUID,
	chatID uuid.UUID,
) error

TouchStep bumps the step's and its parent run's updated_at timestamps without changing any other fields. This prevents long-running operations (e.g. streaming) from being prematurely swept by FinalizeStale, which first marks runs stale by chat_debug_runs.updated_at and then cascades to steps whose run_id was just finalized.

func (*Service) UpdateRun ¶

func (s *Service) UpdateRun(
	ctx context.Context,
	params UpdateRunParams,
) (database.ChatDebugRun, error)

UpdateRun updates an existing debug run and emits a run update event. When a terminal status is set without an explicit FinishedAt, the service auto-fills the timestamp so the row is immediately visible to the InsertChatDebugStep atomic guard (finished_at IS NULL). UpdateChatDebugRun itself enforces finished_at as write-once: once the column is populated, repeated auto-fills or explicit refreshes never overwrite the original completion timestamp, so calling this more than once on an already-finalized run is idempotent.

func (*Service) UpdateStep ¶

func (s *Service) UpdateStep(
	ctx context.Context,
	params UpdateStepParams,
) (database.ChatDebugStep, error)

UpdateStep updates an existing debug step and emits a step update event. When a terminal status is set without an explicit FinishedAt, the service auto-fills the timestamp so the stale sweep does not leave terminal rows with finished_at = NULL.

func (Status) IsTerminal ¶

func (s Status) IsTerminal() bool

IsTerminal reports whether the status represents a final state that should not be overwritten by stale callbacks.

func (Status) Priority ¶

func (s Status) Priority() int

Priority returns a numeric ordering used to prevent stale callbacks from regressing a step's status. Higher values win over lower ones.