Method SendTestCore

internal/agent/api.go:1230–1273

SendTestCore composes and sends (or HITL-holds) a platform test email to the agent's own address. HTTP-free; shared by the legacy handler and the v1 layer. The caller has already authed, resolved + owned the agent, domain-verified, and run the message-send cap.

(ctx context.Context, agent *identity.AgentIdentity)

// layer. The caller has already authed, resolved + owned the agent,
// domain-verified, and run the message-send cap.
func (a *API) SendTestCore(ctx context.Context, agent *identity.AgentIdentity) (*OutboundResult, *OutboundError) {
	envelopeFrom := fmt.Sprintf("noreply@%s", a.fromDomain)
	headerFrom := fmt.Sprintf("%q <%s>", "e2a", envelopeFrom)
	to := []string{agent.EmailAddress()}
	subject := "Test email from e2a"
	body := fmt.Sprintf("This is a test email for %s.\n\nYour agent is set up and ready to receive emails.", agent.EmailAddress())

	// A platform test is a normal outbound send through the same screening:
	// block ⇒ refuse, review ⇒ hold, flag ⇒ send + annotate.
	testReq := outbound.SendRequest{To: to, Subject: subject, Body: body}
	verdict := a.screenOutbound(ctx, agent, testReq)
	if verdict.Block() {
		a.auditRowless(ctx, agent, blockAuditID(agent.ID, testReq), testReq, verdict)
		a.emitBlockedOutbound(agent, blockAuditID(agent.ID, testReq), testReq, verdict)
		return nil, &OutboundError{http.StatusForbidden, "blocked_by_policy", "test message blocked by outbound policy"}
	}
	if verdict.Review() {
		msg, err := a.HoldForApprovalCore(ctx, agent, testReq, "test", "")
		if err != nil {
			return nil, &OutboundError{http.StatusInternalServerError, "internal_error", "failed to hold message for approval"}
		}
		if verdict.Annotate() {
			a.annotateAndAudit(ctx, agent, msg.ID, testReq, verdict)
		}
		return &OutboundResult{Held: true, PendingMessageID: msg.ID, ApprovalExpiresAt: msg.ApprovalExpiresAt}, nil
	}

	message, err := outbound.ComposeMessage(headerFrom, to, nil, subject, body, "text/plain", "", nil, a.fromDomain, "", "")
	if err != nil {
		log.Printf("[api] compose test email failed: %v", err)
		return nil, &OutboundError{http.StatusInternalServerError, "internal_error", "failed to compose test email"}
	}
	messageID, err := a.smtpRelay.Send(envelopeFrom, to, message)
	if err != nil {
		log.Printf("[api] send test email failed: %v", err)
		return nil, &OutboundError{http.StatusInternalServerError, "internal_error", fmt.Sprintf("failed to send test email: %v", err)}
	}
	log.Printf("[api] test email sent to %s (message_id=%s)", agent.EmailAddress(), messageID)
	// flag verdict: the test send persists no message row, so audit row-less.
	if verdict.Annotate() {
		a.auditRowless(ctx, agent, blockAuditID(agent.ID, testReq), testReq, verdict)
	}
	return &OutboundResult{MessageID: messageID, Method: "smtp"}, nil
}

// --- Send Email ---