What causes "invalid payloadBase64: %w" in t8y2/dbx?

Re-encode the payload with standard base64 (with padding) and pass the exact string.

invalid payloadBase64: %w

Error message

invalid payloadBase64: %w

What it means

decodePayload decodes the 'payloadBase64' parameter with Go's standard base64 encoder when it is provided; if the string is not valid standard base64, sendMessage fails with 'invalid payloadBase64: <decode error>'. The driver only falls back to plain 'payload'/'payloadText' when payloadBase64 is absent or empty, so a present-but-invalid value always aborts the send.

Source

Thrown at agents/drivers/rocketmq/helpers.go:120

		switch typed := value.(type) {
		case bool:
			return typed
		case string:
			parsed, err := strconv.ParseBool(strings.TrimSpace(typed))
			if err == nil {
				return parsed
			}
		}
	}
	return defaultValue
}

func decodePayload(params map[string]any) ([]byte, error) {
	encoded := stringValue(params, "payloadBase64")
	if encoded != "" {
		payload, err := base64.StdEncoding.DecodeString(encoded)
		if err != nil {
			return nil, fmt.Errorf("invalid payloadBase64: %w", err)
		}
		return payload, nil
	}
	return []byte(stringValue(params, "payload", "payloadText")), nil
}

func splitAddresses(value string) []string {
	fields := strings.FieldsFunc(value, func(char rune) bool {
		return char == ';' || char == ',' || char == '\n' || char == '\r' || char == '\t' || char == ' '
	})
	seen := map[string]struct{}{}
	result := make([]string, 0, len(fields))
	for _, field := range fields {
		address := strings.TrimSpace(field)
		if address == "" {
			continue
		}
		if _, ok := seen[address]; ok {

View on GitHub (pinned to c0390bff16)

Solutions

Re-encode the payload with standard base64 (with padding) and pass the exact string.
Strip whitespace/newlines and any 'data:...;base64,' prefix before passing.
If your source is URL-safe base64, convert it to standard encoding (replace '-'/'+' and '_'/'/', re-pad).
Alternatively drop payloadBase64 and pass the raw text via 'payload' or 'payloadText'.

Example fix

// before
params := map[string]any{"payloadBase64": "data:application/json;base64,eyJhIjox"}
// after
encoded := base64.StdEncoding.EncodeToString([]byte(`{"a":1}`))
params := map[string]any{"payloadBase64": encoded}

Defensive patterns

Strategy: validation

Validate before calling

encoded := params["payloadBase64"]
if s, ok := encoded.(string); ok && s != "" {
    cleaned := strings.Map(func(r rune) rune { if unicode.IsSpace(r) { return -1 }; return r }, s)
    if _, err := base64.StdEncoding.DecodeString(cleaned); err != nil {
        return fmt.Errorf("payloadBase64 is not valid standard base64: %w", err)
    }
}

Type guard

func isStdBase64(s string) bool {
    if s == "" { return false }
    _, err := base64.StdEncoding.DecodeString(s)
    return err == nil
}

Try / catch

_, err := agent.SendMessage(ctx, params)
if err != nil && strings.Contains(err.Error(), "invalid payloadBase64") {
    // re-encode payload client-side with base64.StdEncoding and retry once, or switch to 'payloadText'
}

Prevention

Always produce payloadBase64 with the standard encoder (StdEncoding), not URL-safe variants.
Never embed data-URI prefixes or whitespace in the base64 string.
Prefer passing plain text via 'payload'/'payloadText' when content is textual.
Beware HTTP layers that convert '+' to spaces in query strings — send base64 in a JSON body.

When it happens

Trigger: Calling sendMessage with payloadBase64 containing whitespace, URL-safe base64 (-, _) without padding fixes, data-URI prefixes like 'data:text/plain;base64,', untrimmed newlines, or truncated strings.

Common situations: Encoding with URL-safe base64 in another language/service then passing it here; copying a base64 blob that got line-wrapped by an editor or log; prepending a data-URI scheme; a serializer escaping the '+' character to a space in a query string.

Related errors

AI-assisted analysis of t8y2/dbx@c0390bff16 (2026-09-05). Data as JSON: /api/errors/cab71bf9c2d49ef6. Report an issue: GitHub.