Removes production code in `coderd/x/chatd` that nothing reaches, the tests that only existed to exercise it, and option/config fields that callers filled in but chatd never read. No runtime behaviour changes; the only edits outside `coderd/x/chatd` drop the now-nonexistent fields at their three call sites (`coderd/coderd.go`, `coderd/exp_chats.go`, `coderd/coderdtest`). Net: 42 files, +147 / -1065. Verification method for every item: `golang.org/x/tools/cmd/deadcode` (with and without `-test`) rooted at `cmd/coder`, `enterprise/cmd/coder` and every package that imports chatd; a `go/packages` pass counting `TypesInfo.Uses` per declared type, const, var, field and method across the same roots, split into test and non-test use sites, plus a read-vs-write split for struct fields; `rg` over the whole repo including `site/src` for json tag names; then `go build ./...`, `go vet ./coderd/x/chatd/...`, `golangci-lint run ./coderd/x/chatd/... ./coderd/ ./coderd/coderdtest/`, and `go test ./coderd/x/chatd/...` (all 20 packages) locally. <details> <summary>Evidence per deletion</summary> | Removed | What it was | Why unused | |---|---|---| | `subagent.go` `resolveConfiguredModelOverride`, `parseModelOverride`, `parsedModelOverride` (~135 lines) + `TestResolveConfiguredModelOverride_*`, `TestParseModelOverride` | raw-string model override resolver | Only callers were its two tests; production resolves overrides through `resolveOrganizationModelOverride` (`title_override.go`, `compaction_override.go`, `subagent.go`). | | `chatd.go` `removeSkillIndexMessages`, `isSkillIndexMessage` + `TestSkillIndexRefreshReplacesStaleAliases` | skill-index refresh helpers | Zero production references; the test simulated a refresh path no production code performs. | | `chatd.go` `chatMessage`, `newChatMessage`, `withCreatedBy`, `appendMessageFields`, `BuildSingleChatMessageInsertParams` (~90 lines) | insert-params builder | Exported, but every caller was a `chatd_test` file (6 sites). Replaced by a 25-line `singleChatMessageInsertParams` helper in `chatd_helpers_test.go`. | | `chatd.go` `Server.closeInflightAdmission` | one-line wrapper around `inflightClosed.Store(true)` | Single call site (`Close`); inlined. | | `chatd.go` `Server.workerID`, `instructionLookupTimeout`, `pendingChatAcquireInterval`, `maxChatsPerAcquire`, `chatHeartbeatInterval` | Server struct fields | Assigned in `New` and never read anywhere (the values reach the worker through `chatWorkerOptions`, not these fields). | | `Config.InstructionLookupTimeout`, `homeInstructionLookupTimeout`, `coderd.Options.ChatdInstructionLookupTimeout`, `coderdtest.Options.ChatdInstructionLookupTimeout` | timeout plumbing | The value only landed in the dead `Server.instructionLookupTimeout`; no CLI flag sets it and nothing reads it. | | `PromoteQueuedOptions.CreatedBy` | option field | Set by `coderd/exp_chats.go` and three tests, never read in chatd (promotion keeps the queued row's `created_by`). | | `SubmitToolResultsOptions.DynamicTools` | option field | Set by `coderd/exp_chats.go` (which re-read `chat.DynamicTools` just to pass it) and three tests, never read in chatd. | | `attachments.go` `buildAssistantPartsForPersist` (whole file) | assistant part builder | Stale copy left by #26270; production uses `buildAssistantParts` in `message_conversion.go`. Its six tests were retargeted to the live function (now `message_conversion_internal_test.go`) and a dead-copy assertion in `subagent_internal_test.go` was dropped. | | `chatloop.RunOptions` (94 lines) | old loop options struct | Only two of 23 fields were ever populated, for one internal call to `prepareMessagesForRequest`, which now takes `model, logger` directly and no longer returns the ignored canonical slice. `GenerateAssistantOptions` / `ExecuteLocalToolsOptions` are the live types. | | `chatloop.ErrDynamicToolCall`, `ErrStopAfterTool`, `PendingToolCall`, `PersistedStep.PendingDynamicToolCalls` | dynamic-tool exit protocol | Zero references outside their declarations (one stale comment in `chatdebug/service.go` updated). | | `chatloop.CompactionOptions.Persist`, `.OnError` | callbacks | `Persist` had zero references; `OnError` was set only by two tests that asserted it was never invoked. | | `chatloop` `stepResult.shouldContinue` + its computation | flag | Written once, never read. | | `chatloop.StateWaiting` | metric label const | Zero references. | | `generation.go` `generationOutcome.InsertedMessages`, `runnerActionMessage` | outcome field | Built on every commit, never read. | | `chatstate` `ExecutionState.IsArchived`, `AllOwnershipStates`, `OwnershipState`/`StateU`/`StateO`, `TransitionAcquire` | state-machine leftovers | Zero references (the ownership consts became dead once `AllOwnershipStates` went). | | `chatstate` `ExecutionState.QueueNonEmpty` | predicate | Only referenced by the test asserting its own table; the sibling `IsRunnable` check in that test is kept. | | `chatdebug.Attempt.RetryClassification`, `.RetryDelayMs` | json fields | Never assigned anywhere, `omitempty`, and `retry_classification`/`retry_delay_ms` do not appear in `site/src` or `typesGenerated.ts`. | | `chatdebug.RunContext.Kind`, `StepContext.HistoryTipMessageID`, `RecorderOptions.Provider`/`.Model`, `stepHandle.opts`/`.usage`/`.err` | context/handle fields | Written (from `chatd.go`, `chatloop/compaction.go`, `modelcall.go`, `recorder.go`) and never read. The DB run row keeps its own `kind` column. | | `chatprovider.MergeProviderAPIKeys` + `TestMergeProviderAPIKeys_PreservesProviderRegions` | key merge | Superseded by `ResolveUserProviderKeys`, whose region test already covers the same behaviour. | | `chatprovider` `providerCreationError` | one-line `xerrors.Errorf` wrapper | Single call site; inlined with identical message. | | `chatretry.IsRetryable` | classifier wrapper | Zero references. | | `computeruse.IsTool` + `TestComputerUseTool` | one-line forwarder to `fantasyopenai.IsComputerUseTool` | No production caller; two test assertions now call the fantasy function directly, and the dropped test only asserted the library's own constructor. | | `chatprompt.ToolResultToPart` | one-line forwarder to `codersdk.ChatMessageToolResult` | Single call site; inlined. | | `subagent_catalog.go` `formatSubagentDefinitions` | forwarder with `nil` overrides | Single call site; inlined. | | `worker.go` `chatWorker.chatWorkerID` | getter | Only tests called it; they read `opts.WorkerID` directly now. | | `chattest.AnthropicErrorResponse`, `OpenAIServerErrorResponse`, `ChatMessageWithParts` (`messages.go` removed) | test fixtures | Zero references. | | `chattest` `AnthropicRequest.Options`, `OpenAIRequest.Options` | `json:",inline"` map fields | `encoding/json` has no inline tag (the TODO on each said so); never populated, never read. | </details> <details> <summary>Considered and kept</summary> - `chatstate.CreateChat` (test-only thin wrapper over `insertChat`, production uses `CreateChatWithID`): documented package API with 25 test call sites; not worth the churn. - `chatprompt.MarshalContent` / `MarshalToolResult`: test-only, but they deliberately produce legacy-format DB rows so the read path's legacy handling stays covered. - `chatstate.AllowedExecutionTransitionsFrom` / `AllowedInputStates` / `AllowedExecutionTransitionOutputs`, `chatdebug.StepFromContext`, `WithClock`, `WithStaleThreshold`, `WaitUntilIdleForTest`, `PublishBuffer.BufferedChannels`, `chattool.NewWorkspaceMCPTool`: test seams that tests actively use to reach otherwise unexported state. - `AgentCapacityLimiter` interface (one production implementation): tests inject fakes. - `applyHookResultMessages` / `appendHookResultMessages`: a named pair over one placement enum, both used. - Nil-receiver guards on `*Metrics`, `*Result`, `*streamSyncPoller`, `*runnerDebugTurn`: nil is a supported "disabled" value on those paths. - Tests flagged by heuristics as assertion-light (`TestNopMetrics_DoesNotPanic`, `TestStepHandleFinish_NilHandle`, `TestRetry_OnRetryNilDoesNotPanic`, the `chatstate` synthetic-cancellation tests that assert through helpers): they cover real nil-safety or delegate assertions to helpers; kept. </details> <details> <summary>Out-of-scope findings (not changed here)</summary> - `chatdebug.Service.FinalizeStale` has had no production caller since #26270 removed the background sweep loop; only its tests call it, and comments in `chatd_debug.go` and `database/querier.go` still describe the loop. Deleting it would erase the implementation a fix needs, so it is left for a decision. - `coderd_chatd_chats` (gauge) and `coderd_chatd_stream_buffer_dropped_total` (counter) are registered and documented in `docs/admin/integrations/prometheus.md` but never set or incremented in production; `Metrics.RecordStreamBufferDropped` is test-only. Removing them changes the exported metric set and the docs, so they are left alone. </details> ## Declined review findings None yet. > Xum (AI agent) opened this PR on behalf of @ibetitsmike.
359 lines
9.5 KiB
Go
359 lines
9.5 KiB
Go
package chatdebug
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"charm.land/fantasy"
|
|
"github.com/google/uuid"
|
|
|
|
"cdr.dev/slog/v3"
|
|
)
|
|
|
|
// RecorderOptions identifies the chat/model context for debug recording.
|
|
type RecorderOptions struct {
|
|
ChatID uuid.UUID
|
|
OwnerID uuid.UUID
|
|
}
|
|
|
|
// WrapModel returns model unchanged when debug recording is disabled, or a
|
|
// debug wrapper when a service is available.
|
|
func WrapModel(
|
|
model fantasy.LanguageModel,
|
|
svc *Service,
|
|
opts RecorderOptions,
|
|
) fantasy.LanguageModel {
|
|
if model == nil {
|
|
panic("chatdebug: nil LanguageModel")
|
|
}
|
|
if svc == nil {
|
|
return model
|
|
}
|
|
return &debugModel{inner: model, svc: svc, opts: opts}
|
|
}
|
|
|
|
type attemptSink struct {
|
|
mu sync.Mutex
|
|
attempts []Attempt
|
|
attemptCounter atomic.Int32
|
|
}
|
|
|
|
func (s *attemptSink) nextAttemptNumber() int {
|
|
if s == nil {
|
|
panic("chatdebug: nil attemptSink")
|
|
}
|
|
return int(s.attemptCounter.Add(1))
|
|
}
|
|
|
|
func (s *attemptSink) record(a Attempt) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
s.attempts = append(s.attempts, a)
|
|
}
|
|
|
|
// replaceByNumber overwrites a previously recorded attempt whose Number
|
|
// matches. If no match is found, the attempt is appended. This supports
|
|
// the provisional-then-upgrade flow used for SSE bodies where Read()
|
|
// records a completed attempt on EOF and Close() later needs to replace
|
|
// it with a failed attempt when inner.Close() surfaces an error.
|
|
func (s *attemptSink) replaceByNumber(number int, a Attempt) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
for i := range s.attempts {
|
|
if s.attempts[i].Number == number {
|
|
s.attempts[i] = a
|
|
return
|
|
}
|
|
}
|
|
s.attempts = append(s.attempts, a)
|
|
}
|
|
|
|
func (s *attemptSink) snapshot() []Attempt {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
attempts := make([]Attempt, len(s.attempts))
|
|
copy(attempts, s.attempts)
|
|
return attempts
|
|
}
|
|
|
|
type attemptSinkKey struct{}
|
|
|
|
func withAttemptSink(ctx context.Context, sink *attemptSink) context.Context {
|
|
if sink == nil {
|
|
panic("chatdebug: nil attemptSink")
|
|
}
|
|
return context.WithValue(ctx, attemptSinkKey{}, sink)
|
|
}
|
|
|
|
func attemptSinkFromContext(ctx context.Context) *attemptSink {
|
|
sink, _ := ctx.Value(attemptSinkKey{}).(*attemptSink)
|
|
return sink
|
|
}
|
|
|
|
var stepCounters sync.Map // map[uuid.UUID]*atomic.Int32
|
|
|
|
// runRefCounts tracks how many live RunContext instances reference each
|
|
// RunID. Cleanup of shared state (step counters) is deferred until the
|
|
// last RunContext for a given RunID is garbage collected.
|
|
var (
|
|
runRefCounts sync.Map // map[uuid.UUID]*atomic.Int32
|
|
// refCountMu serializes trackRunRef and releaseRunRef so the
|
|
// decrement-to-zero check and subsequent map deletions are
|
|
// atomic with respect to new references being added.
|
|
refCountMu sync.Mutex
|
|
)
|
|
|
|
func trackRunRef(runID uuid.UUID) {
|
|
refCountMu.Lock()
|
|
defer refCountMu.Unlock()
|
|
val, _ := runRefCounts.LoadOrStore(runID, &atomic.Int32{})
|
|
counter, ok := val.(*atomic.Int32)
|
|
if !ok {
|
|
panic("chatdebug: runRefCounts contains non-*atomic.Int32 value")
|
|
}
|
|
counter.Add(1)
|
|
}
|
|
|
|
// releaseRunRef decrements the reference count for runID and cleans up
|
|
// shared state when the last reference is released. The mutex ensures
|
|
// no concurrent trackRunRef can increment between the zero check and
|
|
// the map deletions.
|
|
func releaseRunRef(runID uuid.UUID) {
|
|
refCountMu.Lock()
|
|
defer refCountMu.Unlock()
|
|
val, ok := runRefCounts.Load(runID)
|
|
if !ok {
|
|
return
|
|
}
|
|
counter, ok := val.(*atomic.Int32)
|
|
if !ok {
|
|
panic("chatdebug: runRefCounts contains non-*atomic.Int32 value")
|
|
}
|
|
if counter.Add(-1) <= 0 {
|
|
runRefCounts.Delete(runID)
|
|
stepCounters.Delete(runID)
|
|
}
|
|
}
|
|
|
|
func nextStepNumber(runID uuid.UUID) int32 {
|
|
val, _ := stepCounters.LoadOrStore(runID, &atomic.Int32{})
|
|
counter, ok := val.(*atomic.Int32)
|
|
if !ok {
|
|
panic("chatdebug: invalid step counter type")
|
|
}
|
|
return counter.Add(1)
|
|
}
|
|
|
|
// CleanupStepCounter removes per-run step counter and reference count
|
|
// state. This is used by tests and later stacked branches that have a
|
|
// real run lifecycle.
|
|
func CleanupStepCounter(runID uuid.UUID) {
|
|
stepCounters.Delete(runID)
|
|
runRefCounts.Delete(runID)
|
|
}
|
|
|
|
const stepFinalizeTimeout = 5 * time.Second
|
|
|
|
func stepFinalizeContext(ctx context.Context) (context.Context, context.CancelFunc) {
|
|
if ctx == nil {
|
|
panic("chatdebug: nil context")
|
|
}
|
|
return context.WithTimeout(context.WithoutCancel(ctx), stepFinalizeTimeout)
|
|
}
|
|
|
|
func syncStepCounter(runID uuid.UUID, stepNumber int32) {
|
|
val, _ := stepCounters.LoadOrStore(runID, &atomic.Int32{})
|
|
counter, ok := val.(*atomic.Int32)
|
|
if !ok {
|
|
panic("chatdebug: invalid step counter type")
|
|
}
|
|
for {
|
|
current := counter.Load()
|
|
if current >= stepNumber {
|
|
return
|
|
}
|
|
if counter.CompareAndSwap(current, stepNumber) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
type stepHandle struct {
|
|
stepCtx *StepContext
|
|
sink *attemptSink
|
|
svc *Service
|
|
mu sync.Mutex
|
|
status Status
|
|
response any
|
|
metadata any
|
|
// hadError tracks whether a prior finalization wrote an error
|
|
// payload. Used to decide whether a successful retry needs to
|
|
// explicitly clear the error field via jsonClear.
|
|
hadError bool
|
|
}
|
|
|
|
// beginStep validates preconditions, creates a debug step, and returns a
|
|
// handle plus an enriched context carrying StepContext and attemptSink.
|
|
// Returns (nil, original ctx) when debug recording should be skipped.
|
|
func beginStep(
|
|
ctx context.Context,
|
|
svc *Service,
|
|
opts RecorderOptions,
|
|
op Operation,
|
|
normalizedReq any,
|
|
) (*stepHandle, context.Context) {
|
|
if svc == nil {
|
|
return nil, ctx
|
|
}
|
|
|
|
rc, ok := RunFromContext(ctx)
|
|
if !ok || rc.RunID == uuid.Nil {
|
|
return nil, ctx
|
|
}
|
|
|
|
chatID := opts.ChatID
|
|
if chatID == uuid.Nil {
|
|
chatID = rc.ChatID
|
|
}
|
|
if !svc.IsEnabled(ctx, chatID, opts.OwnerID) {
|
|
return nil, ctx
|
|
}
|
|
|
|
holder, reuseStep := reuseHolderFromContext(ctx)
|
|
if reuseStep {
|
|
holder.mu.Lock()
|
|
defer holder.mu.Unlock()
|
|
// Only reuse the cached handle if it belongs to the same run.
|
|
// A different RunContext means a new logical run, so we must
|
|
// create a fresh step to avoid cross-run attribution.
|
|
if holder.handle != nil && holder.handle.stepCtx.RunID == rc.RunID {
|
|
enriched := ContextWithStep(ctx, holder.handle.stepCtx)
|
|
enriched = withAttemptSink(enriched, holder.handle.sink)
|
|
return holder.handle, enriched
|
|
}
|
|
}
|
|
|
|
stepNum := nextStepNumber(rc.RunID)
|
|
step, err := svc.CreateStep(ctx, CreateStepParams{
|
|
RunID: rc.RunID,
|
|
ChatID: chatID,
|
|
StepNumber: stepNum,
|
|
Operation: op,
|
|
Status: StatusInProgress,
|
|
HistoryTipMessageID: rc.HistoryTipMessageID,
|
|
NormalizedRequest: normalizedReq,
|
|
})
|
|
if err != nil {
|
|
svc.log.Warn(ctx, "failed to create chat debug step",
|
|
slog.Error(err),
|
|
slog.F("chat_id", chatID),
|
|
slog.F("run_id", rc.RunID),
|
|
slog.F("operation", op),
|
|
)
|
|
return nil, ctx
|
|
}
|
|
|
|
syncStepCounter(rc.RunID, step.StepNumber)
|
|
actualStepNumber := step.StepNumber
|
|
if actualStepNumber == 0 {
|
|
actualStepNumber = stepNum
|
|
}
|
|
|
|
sc := &StepContext{
|
|
StepID: step.ID,
|
|
RunID: rc.RunID,
|
|
ChatID: chatID,
|
|
StepNumber: actualStepNumber,
|
|
Operation: op,
|
|
}
|
|
handle := &stepHandle{stepCtx: sc, sink: &attemptSink{}, svc: svc}
|
|
enriched := ContextWithStep(ctx, handle.stepCtx)
|
|
enriched = withAttemptSink(enriched, handle.sink)
|
|
if reuseStep {
|
|
holder.handle = handle
|
|
}
|
|
|
|
return handle, enriched
|
|
}
|
|
|
|
// finish updates the debug step with final status and data. A mutex
|
|
// guards the write so concurrent callers (e.g. retried stream wrappers
|
|
// sharing a reuse handle) don't race. Later retries are allowed to
|
|
// overwrite earlier failure results so the step reflects the final
|
|
// outcome, but stale callbacks cannot regress a terminal state.
|
|
func (h *stepHandle) finish(
|
|
ctx context.Context,
|
|
status Status,
|
|
response any,
|
|
usage any,
|
|
errPayload any,
|
|
metadata any,
|
|
) {
|
|
if h == nil || h.stepCtx == nil {
|
|
return
|
|
}
|
|
|
|
h.mu.Lock()
|
|
defer h.mu.Unlock()
|
|
|
|
// Reject stale callbacks that would regress a terminal state.
|
|
// Status priority: in_progress < interrupted < error < completed.
|
|
// A tardy safety-net writing "interrupted" cannot clobber a step
|
|
// that already reached "completed" or "error" from a real retry.
|
|
// Equal-priority updates are allowed so that retries ending in the
|
|
// same terminal class (e.g. error → error under ReuseStep) can
|
|
// still update the step with newer attempt data.
|
|
if h.status.IsTerminal() && status.Priority() < h.status.Priority() {
|
|
return
|
|
}
|
|
|
|
h.status = status
|
|
h.response = response
|
|
h.metadata = metadata
|
|
if errPayload != nil {
|
|
h.hadError = true
|
|
}
|
|
if h.svc == nil {
|
|
return
|
|
}
|
|
|
|
updateCtx, cancel := stepFinalizeContext(ctx)
|
|
defer cancel()
|
|
|
|
// When the step completes successfully after a prior failed
|
|
// attempt, the error field must be explicitly cleared. A plain
|
|
// nil would leave the COALESCE-based SQL untouched, so we send
|
|
// jsonClear{} which serializes as a valid JSONB null. Only do
|
|
// this when a prior error was actually recorded; otherwise
|
|
// clean successes would get a spurious JSONB null that downstream
|
|
// aggregation could misread as an error.
|
|
errValue := errPayload
|
|
if errValue == nil && status == StatusCompleted && h.hadError {
|
|
errValue = jsonClear{}
|
|
}
|
|
|
|
if _, updateErr := h.svc.UpdateStep(updateCtx, UpdateStepParams{
|
|
ID: h.stepCtx.StepID,
|
|
ChatID: h.stepCtx.ChatID,
|
|
Status: status,
|
|
NormalizedResponse: response,
|
|
Usage: usage,
|
|
Attempts: h.sink.snapshot(),
|
|
Error: errValue,
|
|
Metadata: metadata,
|
|
FinishedAt: h.svc.clock.Now(),
|
|
}); updateErr != nil {
|
|
h.svc.log.Warn(updateCtx, "failed to finalize chat debug step",
|
|
slog.Error(updateErr),
|
|
slog.F("step_id", h.stepCtx.StepID),
|
|
slog.F("chat_id", h.stepCtx.ChatID),
|
|
slog.F("status", status),
|
|
)
|
|
}
|
|
}
|