Method InterruptChat

coderd/x/chatd/chatd.go:2855–2901

InterruptChat interrupts execution, sets waiting status, and broadcasts status updates.

(
	ctx context.Context,
	chat database.Chat,
)

// InterruptChat interrupts execution, sets waiting status, and broadcasts status updates.
func (p *Server) InterruptChat(
	ctx context.Context,
	chat database.Chat,
) database.Chat {
	if chat.ID == uuid.Nil {
		return chat
	}

	// If the chat is in requires_action, insert synthetic error
	// tool-result messages for each pending dynamic tool call
	// before transitioning to waiting. Without this, the LLM
	// would see unmatched tool-call parts on the next run.
	if chat.Status == database.ChatStatusRequiresAction {
		if txErr := p.db.InTx(func(tx database.Store) error {
			locked, lockErr := tx.GetChatByIDForUpdate(ctx, chat.ID)
			if lockErr != nil {
				return xerrors.Errorf("lock chat for interrupt: %w", lockErr)
			}
			// Another request may have already transitioned
			// the chat (e.g. SubmitToolResults committed
			// between our snapshot and this lock).
			if locked.Status != database.ChatStatusRequiresAction {
				return nil
			}
			_, err := insertSyntheticToolResultsTx(ctx, tx, locked, "Tool execution interrupted by user")
			return err
		}, nil); txErr != nil {
			p.logger.Error(ctx, "failed to insert synthetic tool results during interrupt",
				slog.F("chat_id", chat.ID),
				slog.Error(txErr),
			)
			// Fall through — still try to set waiting status.
		}
	}

	// Debug runs are finalized in the execution path when the owning
	// goroutine observes cancellation, so we do not mutate debug state here.
	updatedChat, err := p.setChatWaiting(ctx, chat.ID)
	if err != nil {
		p.logger.Error(ctx, "failed to mark chat as waiting",
			slog.F("chat_id", chat.ID),
			slog.Error(err),
		)
		return chat
	}
	return updatedChat
}

const manualTitleMessageWindowLimit = 50