Method SubmitToolResults

coderd/x/chatd/chatd.go:2659–2852

SubmitToolResults validates and persists client-provided tool results, transitions the chat to pending, and wakes the run loop. The caller is responsible for the fast-path status check; this method performs an authoritative re-check under a row lock.

(
	ctx context.Context,
	opts SubmitToolResultsOptions,
)

// loop. The caller is responsible for the fast-path status check;
// this method performs an authoritative re-check under a row lock.
func (p *Server) SubmitToolResults(
	ctx context.Context,
	opts SubmitToolResultsOptions,
) error {
	dynamicToolNames, err := parseDynamicToolNames(pqtype.NullRawMessage{
		RawMessage: opts.DynamicTools,
		Valid:      len(opts.DynamicTools) > 0,
	})
	if err != nil {
		return xerrors.Errorf("parse chat dynamic tools: %w", err)
	}

	// The GetLastChatMessageByRole lookup and all subsequent
	// validation and persistence run inside a single transaction
	// so the assistant message cannot change between reads.
	var statusConflict *ToolResultStatusConflictError
	txErr := p.db.InTx(func(tx database.Store) error {
		// Authoritative status check under row lock.
		locked, lockErr := tx.GetChatByIDForUpdate(ctx, opts.ChatID)
		if lockErr != nil {
			return xerrors.Errorf("lock chat for update: %w", lockErr)
		}
		if locked.Archived {
			return ErrChatArchived
		}
		if locked.Status != database.ChatStatusRequiresAction {
			statusConflict = &ToolResultStatusConflictError{
				ActualStatus: locked.Status,
			}
			return statusConflict
		}

		// Get the last assistant message inside the transaction
		// for consistency with the row lock above.
		lastAssistant, err := tx.GetLastChatMessageByRole(ctx, database.GetLastChatMessageByRoleParams{
			ChatID: opts.ChatID,
			Role:   database.ChatMessageRoleAssistant,
		})
		if err != nil {
			return xerrors.Errorf("get last assistant message: %w", err)
		}

		// Collect tool-call IDs that already have results.
		// When a dynamic tool name collides with a built-in,
		// the chatloop executes it as a built-in and persists
		// the result. Those calls must not count as pending.
		afterMsgs, afterErr := tx.GetChatMessagesByChatID(ctx, database.GetChatMessagesByChatIDParams{
			ChatID:  opts.ChatID,
			AfterID: lastAssistant.ID,
		})
		if afterErr != nil {
			return xerrors.Errorf("get messages after assistant: %w", afterErr)
		}
		handledCallIDs := make(map[string]bool)
		for _, msg := range afterMsgs {
			if msg.Role != database.ChatMessageRoleTool {
				continue
			}