Solve captchas from Go with one function

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"time"
)

const apiURL = "https://bypass.so"

var httpClient = &http.Client{Timeout: 30 * time.Second}

// BypassError is returned for every API reply with a non-zero errorId.
type BypassError struct {
	Code        string
	Description string
	TaskID      string
}

func (e *BypassError) Error() string { return e.Code + ": " + e.Description }

// Solution holds the answer. Text is set for recognition types, Token for widget types.
type Solution struct {
	Text               string  `json:"text,omitempty"`
	Token              string  `json:"token,omitempty"`
	GRecaptchaResponse string  `json:"gRecaptchaResponse,omitempty"`
	TokenField         string  `json:"tokenField,omitempty"`
	TokenLifetime      float64 `json:"tokenLifetime,omitempty"`
	TaskID             string  `json:"-"`
}

// Answer returns the token or text, whichever this task type produces.
func (s *Solution) Answer() string {
	switch {
	case s.GRecaptchaResponse != "":
		return s.GRecaptchaResponse
	case s.Token != "":
		return s.Token
	default:
		return s.Text
	}
}

type apiError struct {
	ErrorID          int    `json:"errorId"`
	ErrorCode        string `json:"errorCode"`
	ErrorDescription string `json:"errorDescription"`
	TaskID           string `json:"taskId"`
}

type taskReply struct {
	TaskID   string   `json:"taskId"`
	Status   string   `json:"status"`
	Solution Solution `json:"solution"`
}

func apiKey() string { return os.Getenv("BYPASS_API_KEY") }

// call sends one request and decodes the JSON reply into out, turning errorId != 0 into a *BypassError.
func call(ctx context.Context, method, path string, body any, bearer bool, out any) error {
	var payload io.Reader
	if body != nil {
		b, err := json.Marshal(body)
		if err != nil {
			return err
		}
		payload = bytes.NewReader(b)
	}
	req, err := http.NewRequestWithContext(ctx, method, apiURL+path, payload)
	if err != nil {
		return err
	}
	if body != nil {
		req.Header.Set("Content-Type", "application/json")
	}
	if bearer {
		req.Header.Set("Authorization", "Bearer "+apiKey())
	}
	resp, err := httpClient.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	raw, err := io.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	var head apiError
	if err := json.Unmarshal(raw, &head); err != nil {
		return &BypassError{Code: "HTTP_ERROR", Description: fmt.Sprintf("HTTP %d without a JSON body", resp.StatusCode)}
	}
	if head.ErrorID != 0 {
		if head.ErrorCode == "" {
			head.ErrorCode = "ERROR_UNKNOWN"
		}
		return &BypassError{Code: head.ErrorCode, Description: head.ErrorDescription, TaskID: head.TaskID}
	}
	return json.Unmarshal(raw, out)
}

// Solve creates a task and polls every 2 seconds until it is ready.
// Without a deadline on ctx it gives up after 120 seconds.
func Solve(ctx context.Context, taskType string, params map[string]any) (*Solution, error) {
	key := apiKey()
	if key == "" {
		return nil, &BypassError{Code: "ERROR_KEY_INVALID", Description: "set the BYPASS_API_KEY environment variable"}
	}
	if _, ok := ctx.Deadline(); !ok {
		var cancel context.CancelFunc
		ctx, cancel = context.WithTimeout(ctx, 120*time.Second)
		defer cancel()
	}

	body := map[string]any{"clientKey": key, "type": taskType}
	for k, v := range params {
		body[k] = v
	}
	var r taskReply
	if err := call(ctx, http.MethodPost, "/createTask", body, false, &r); err != nil {
		return nil, err
	}
	taskID := r.TaskID
	poll := "/getTaskResult/" + url.PathEscape(taskID) + "?clientKey=" + url.QueryEscape(key)
	for r.Status != "ready" {
		if r.Status == "failed" {
			return nil, &BypassError{Code: "ERROR_CAPTCHA_UNSOLVABLE", Description: "task failed", TaskID: taskID}
		}
		select {
		case <-ctx.Done():
			return nil, fmt.Errorf("task %s was not ready in time: %w", taskID, ctx.Err())
		case <-time.After(2 * time.Second):
		}
		r = taskReply{}
		if err := call(ctx, http.MethodGet, poll, nil, false, &r); err != nil {
			return nil, err
		}
	}
	sol := r.Solution
	sol.TaskID = taskID
	return &sol, nil
}

type Balance struct {
	Credits    int64   `json:"credits"`
	BalanceUSD float64 `json:"balanceUsd"`
}

// GetBalance returns the balance of the key in BYPASS_API_KEY.
func GetBalance(ctx context.Context) (*Balance, error) {
	var b Balance
	err := call(ctx, http.MethodGet, "/balance", nil, true, &b)
	return &b, err
}

type Report struct {
	TaskID     string  `json:"taskId"`
	Refunded   int64   `json:"refunded"`
	BalanceUSD float64 `json:"balanceUsd"`
}

// ReportBad flags a wrong answer. The price is refunded once and the task is closed.
func ReportBad(ctx context.Context, taskID string) (*Report, error) {
	var r Report
	err := call(ctx, http.MethodPost, "/reportBad?task_id="+url.QueryEscape(taskID), nil, true, &r)
	return &r, err
}