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.
236 lines
8.6 KiB
Go
236 lines
8.6 KiB
Go
package chatstate
|
|
|
|
import "slices"
|
|
|
|
// Transition is the enumeration of transitions implemented by the
|
|
// state machine. Values intentionally match the names of the public
|
|
// methods on [Tx] (and [CreateChat]). The transition matrix below
|
|
// declares the legal (from -> to) execution-state mappings used by
|
|
// each transition method for validation.
|
|
type Transition string
|
|
|
|
const (
|
|
TransitionCreateChat Transition = "CreateChat"
|
|
TransitionSetArchived Transition = "SetArchived"
|
|
TransitionSendMessage Transition = "SendMessage"
|
|
TransitionEditMessage Transition = "EditMessage"
|
|
TransitionRequestCompaction Transition = "RequestCompaction"
|
|
TransitionClearContext Transition = "ClearContext"
|
|
TransitionDeleteQueuedMessage Transition = "DeleteQueuedMessage"
|
|
TransitionPromoteQueuedMessage Transition = "PromoteQueuedMessage"
|
|
TransitionInterrupt Transition = "Interrupt"
|
|
TransitionCompleteRequiresAction Transition = "CompleteRequiresAction"
|
|
TransitionAbandon Transition = "Abandon"
|
|
TransitionRecordGenerationAttempt Transition = "RecordGenerationAttempt"
|
|
TransitionRecordRetryState Transition = "RecordRetryState"
|
|
TransitionCommitStep Transition = "CommitStep"
|
|
TransitionEnterRequiresAction Transition = "EnterRequiresAction"
|
|
TransitionFinishInterruption Transition = "FinishInterruption"
|
|
TransitionFinishTurn Transition = "FinishTurn"
|
|
TransitionFinishError Transition = "FinishError"
|
|
TransitionCancelRequiresAction Transition = "CancelRequiresAction"
|
|
TransitionReconcileInvalidState Transition = "ReconcileInvalidState"
|
|
)
|
|
|
|
// String implements fmt.Stringer.
|
|
func (t Transition) String() string { return string(t) }
|
|
|
|
// AllExecutionTransitions is the canonical enumeration of every
|
|
// execution-state transition that has an entry in the matrix below.
|
|
// Ownership transitions (Acquire, Abandon) are intentionally not part
|
|
// of this slice because they are validated independently and do not
|
|
// have a (from->to) execution mapping.
|
|
var AllExecutionTransitions = []Transition{
|
|
TransitionCreateChat,
|
|
TransitionSetArchived,
|
|
TransitionSendMessage,
|
|
TransitionEditMessage,
|
|
TransitionRequestCompaction,
|
|
TransitionClearContext,
|
|
TransitionDeleteQueuedMessage,
|
|
TransitionPromoteQueuedMessage,
|
|
TransitionInterrupt,
|
|
TransitionCompleteRequiresAction,
|
|
TransitionRecordGenerationAttempt,
|
|
TransitionRecordRetryState,
|
|
TransitionCommitStep,
|
|
TransitionEnterRequiresAction,
|
|
TransitionFinishInterruption,
|
|
TransitionFinishTurn,
|
|
TransitionFinishError,
|
|
TransitionCancelRequiresAction,
|
|
TransitionReconcileInvalidState,
|
|
}
|
|
|
|
// transitionMatrix is the in-code representation of the chat execution
|
|
// state transition table. Each entry maps an input state to the set of
|
|
// allowed transitions together with the possible classified output
|
|
// states that the transition implementation may land in. Outputs may
|
|
// depend on the post-mutation queue cardinality (for example
|
|
// DeleteQueuedMessage from E1 lands in E0 when the deleted row was the
|
|
// last queued message, or stays in E1 otherwise), which is why several
|
|
// entries list more than one output.
|
|
//
|
|
// Ownership transitions (Acquire, Abandon) are intentionally not
|
|
// included; they are orthogonal to execution state.
|
|
var transitionMatrix = map[ExecutionState]map[Transition][]ExecutionState{
|
|
StateN: {
|
|
TransitionCreateChat: {StateR0},
|
|
},
|
|
StateW: {
|
|
TransitionSetArchived: {StateXW},
|
|
TransitionSendMessage: {StateR0},
|
|
TransitionEditMessage: {StateR0},
|
|
TransitionRequestCompaction: {StateR0},
|
|
TransitionClearContext: {StateW},
|
|
TransitionFinishError: {StateE0},
|
|
},
|
|
StateE0: {
|
|
TransitionSetArchived: {StateXE0},
|
|
TransitionSendMessage: {StateR0},
|
|
TransitionEditMessage: {StateR0},
|
|
TransitionRequestCompaction: {StateR0},
|
|
TransitionClearContext: {StateW},
|
|
},
|
|
StateE1: {
|
|
TransitionSetArchived: {StateXE1},
|
|
TransitionSendMessage: {StateR1},
|
|
TransitionEditMessage: {StateR0},
|
|
TransitionDeleteQueuedMessage: {StateE0, StateE1},
|
|
TransitionPromoteQueuedMessage: {StateR0, StateR1},
|
|
TransitionRequestCompaction: {StateR1},
|
|
},
|
|
StateR0: {
|
|
TransitionSendMessage: {StateR1, StateI1},
|
|
TransitionEditMessage: {StateR0},
|
|
TransitionInterrupt: {StateI0},
|
|
TransitionRecordGenerationAttempt: {StateR0},
|
|
TransitionRecordRetryState: {StateR0},
|
|
TransitionCommitStep: {StateR0},
|
|
TransitionEnterRequiresAction: {StateA0},
|
|
TransitionFinishTurn: {StateW},
|
|
TransitionFinishError: {StateE0},
|
|
},
|
|
StateR1: {
|
|
TransitionSendMessage: {StateR1, StateI1},
|
|
TransitionEditMessage: {StateR0},
|
|
TransitionDeleteQueuedMessage: {StateR0, StateR1},
|
|
TransitionPromoteQueuedMessage: {StateI1},
|
|
TransitionInterrupt: {StateI1},
|
|
TransitionRecordGenerationAttempt: {StateR1},
|
|
TransitionRecordRetryState: {StateR1},
|
|
TransitionCommitStep: {StateR1},
|
|
TransitionEnterRequiresAction: {StateA1},
|
|
TransitionFinishTurn: {StateR0, StateR1},
|
|
TransitionFinishError: {StateE1},
|
|
},
|
|
StateI0: {
|
|
TransitionSendMessage: {StateI1},
|
|
TransitionEditMessage: {StateR0},
|
|
TransitionFinishInterruption: {StateW},
|
|
},
|
|
StateI1: {
|
|
TransitionSendMessage: {StateI1},
|
|
TransitionEditMessage: {StateR0},
|
|
TransitionDeleteQueuedMessage: {StateI0, StateI1},
|
|
TransitionPromoteQueuedMessage: {StateI1},
|
|
TransitionFinishInterruption: {StateR0, StateR1},
|
|
},
|
|
StateA0: {
|
|
TransitionSendMessage: {StateA1, StateR1},
|
|
TransitionEditMessage: {StateR0},
|
|
TransitionInterrupt: {StateR0},
|
|
TransitionCompleteRequiresAction: {StateR0},
|
|
TransitionCancelRequiresAction: {StateR0},
|
|
},
|
|
StateA1: {
|
|
TransitionSendMessage: {StateA1, StateR1},
|
|
TransitionEditMessage: {StateR0},
|
|
TransitionDeleteQueuedMessage: {StateA0, StateA1},
|
|
TransitionPromoteQueuedMessage: {StateR0, StateR1},
|
|
TransitionInterrupt: {StateR1},
|
|
TransitionCompleteRequiresAction: {StateR1},
|
|
TransitionCancelRequiresAction: {StateR1},
|
|
},
|
|
StateXW: {
|
|
TransitionSetArchived: {StateW},
|
|
},
|
|
StateXE0: {
|
|
TransitionSetArchived: {StateE0},
|
|
},
|
|
StateXE1: {
|
|
TransitionSetArchived: {StateE1},
|
|
},
|
|
StateInvalid: {
|
|
TransitionReconcileInvalidState: {StateE0, StateE1},
|
|
},
|
|
}
|
|
|
|
// isExecutionTransitionAllowed reports whether a transition is legal
|
|
// from the supplied input state per the matrix above. Ownership
|
|
// transitions are not stored in the matrix and always return false.
|
|
func isExecutionTransitionAllowed(t Transition, from ExecutionState) bool {
|
|
allowed, ok := transitionMatrix[from]
|
|
if !ok {
|
|
return false
|
|
}
|
|
_, ok = allowed[t]
|
|
return ok
|
|
}
|
|
|
|
// requireExecutionTransition validates that t is legal from `from`
|
|
// and returns a typed *TransitionError otherwise.
|
|
func requireExecutionTransition(t Transition, from ExecutionState) error {
|
|
if isExecutionTransitionAllowed(t, from) {
|
|
return nil
|
|
}
|
|
return newTransitionError(t, from, "")
|
|
}
|
|
|
|
// AllowedExecutionTransitionsFrom returns a deterministic slice of
|
|
// transitions legal from `from`. Mostly used by tests to enumerate the
|
|
// matrix without leaking the internal map.
|
|
func AllowedExecutionTransitionsFrom(from ExecutionState) []Transition {
|
|
allowed := transitionMatrix[from]
|
|
out := make([]Transition, 0, len(allowed))
|
|
for _, t := range AllExecutionTransitions {
|
|
if _, ok := allowed[t]; ok {
|
|
out = append(out, t)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// AllowedInputStates returns a deterministic slice of execution states
|
|
// from which `tr` is legal per the matrix above. Mostly used by tests
|
|
// to enumerate the matrix without leaking the internal map.
|
|
func AllowedInputStates(tr Transition) []ExecutionState {
|
|
var out []ExecutionState
|
|
for _, from := range AllExecutionStates {
|
|
if isExecutionTransitionAllowed(tr, from) {
|
|
out = append(out, from)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// AllowedExecutionTransitionOutputs returns the set of classified
|
|
// post-states that the transition `tr` may produce from `from` per
|
|
// the matrix above. The returned slice is a copy so callers may mutate
|
|
// it without affecting the underlying matrix.
|
|
//
|
|
// When `tr` is not allowed from `from`, an empty (nil) slice is
|
|
// returned. Tests use this helper to enumerate the (transition, from,
|
|
// want) triples that must be exercised by the row-level matrix tests.
|
|
func AllowedExecutionTransitionOutputs(from ExecutionState, tr Transition) []ExecutionState {
|
|
allowed, ok := transitionMatrix[from]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
outputs, ok := allowed[tr]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
return slices.Clone(outputs)
|
|
}
|