POST a JSON pair and extract the sum

No reference implementation in this language.

// HTTP POST + JSON sum reference for AgentLang Index.
//
// Reads three stdin lines: URL, a, b. POSTs `{"a":<a>,"b":<b>}` to URL
// with Content-Type: application/json and 5000 ms timeout. On HTTP 200
// with a JSON body containing an integer `sum`, writes the sum and
// newline. Otherwise writes `error\n`. Always exits 0.

async function readStdin(): Promise<string> {
  const chunks: Buffer[] = [];
  for await (const chunk of process.stdin as AsyncIterable<Buffer>) {
    chunks.push(chunk);
  }
  return Buffer.concat(chunks).toString("utf-8");
}

function fail(): void {
  process.stdout.write("error\n");
}

async function main(): Promise<void> {
  let url: string;
  let a: number;
  let b: number;
  try {
    const lines = (await readStdin()).split(/\r?\n/);
    url = (lines[0] ?? "").trim();
    a = parseInt((lines[1] ?? "").trim(), 10);
    b = parseInt((lines[2] ?? "").trim(), 10);
    if (!url || !Number.isInteger(a) || !Number.isInteger(b)) {
      fail();
      return;
    }
  } catch {
    fail();
    return;
  }

  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), 5000);
  let resp: Response;
  try {
    resp = await fetch(url, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: `{"a":${a},"b":${b}}`,
      signal: controller.signal,
      redirect: "manual",
    });
  } catch {
    clearTimeout(timeout);
    fail();
    return;
  }
  clearTimeout(timeout);

  if (resp.status !== 200) {
    fail();
    return;
  }

  let bodyText: string;
  try {
    bodyText = await resp.text();
  } catch {
    fail();
    return;
  }

  let parsed: unknown;
  try {
    parsed = JSON.parse(bodyText);
  } catch {
    fail();
    return;
  }

  if (
    typeof parsed !== "object" ||
    parsed === null ||
    !("sum" in parsed) ||
    typeof (parsed as { sum: unknown }).sum !== "number" ||
    !Number.isInteger((parsed as { sum: number }).sum)
  ) {
    fail();
    return;
  }
  const s = (parsed as { sum: number }).sum;
  process.stdout.write(`${s}\n`);
}

main();

// HTTP POST + JSON sum reference for AgentLang Index.

use std::io::{self, Read};
use std::time::Duration;

fn fail() {
    print!("error\n");
}

fn run() -> Option<i64> {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).ok()?;
    let mut lines = input.lines();
    let url = lines.next()?.trim().to_string();
    let a: i64 = lines.next()?.trim().parse().ok()?;
    let b: i64 = lines.next()?.trim().parse().ok()?;
    let body = format!("{{\"a\":{},\"b\":{}}}", a, b);

    let agent = ureq::Agent::config_builder()
        .timeout_global(Some(Duration::from_secs(5)))
        .build()
        .new_agent();

    let response = agent
        .post(&url)
        .header("Content-Type", "application/json")
        .send(body.as_bytes());

    let mut response = match response {
        Ok(r) => r,
        Err(_) => return None,
    };
    if response.status().as_u16() != 200 {
        return None;
    }
    let body_text = response.body_mut().read_to_string().ok()?;
    let parsed: serde_json::Value = serde_json::from_str(&body_text).ok()?;
    let obj = parsed.as_object()?;
    let sum_val = obj.get("sum")?;
    let s = sum_val.as_i64()?;
    Some(s)
}

fn main() {
    match run() {
        Some(s) => print!("{}\n", s),
        None => fail(),
    }
}

// HTTP POST + JSON sum reference for AgentLang Index.

package main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"
)

func fail() {
	fmt.Print("error\n")
}

func run() bool {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, 0, 4096), 1<<20)
	var lines []string
	for scanner.Scan() {
		lines = append(lines, scanner.Text())
		if len(lines) == 3 {
			break
		}
	}
	if len(lines) < 3 {
		return false
	}
	url := strings.TrimSpace(lines[0])
	a, err := strconv.Atoi(strings.TrimSpace(lines[1]))
	if err != nil {
		return false
	}
	b, err := strconv.Atoi(strings.TrimSpace(lines[2]))
	if err != nil {
		return false
	}
	if url == "" {
		return false
	}

	body := []byte(fmt.Sprintf(`{"a":%d,"b":%d}`, a, b))
	req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(body))
	if err != nil {
		return false
	}
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{
		Timeout: 5 * time.Second,
		CheckRedirect: func(req *http.Request, via []*http.Request) error {
			return http.ErrUseLastResponse
		},
	}
	resp, err := client.Do(req)
	if err != nil {
		return false
	}
	defer resp.Body.Close()
	if resp.StatusCode != 200 {
		return false
	}

	var parsed map[string]json.RawMessage
	dec := json.NewDecoder(resp.Body)
	if err := dec.Decode(&parsed); err != nil {
		return false
	}
	rawSum, ok := parsed["sum"]
	if !ok {
		return false
	}
	var n json.Number
	if err := json.Unmarshal(rawSum, &n); err != nil {
		return false
	}
	s, err := n.Int64()
	if err != nil {
		return false
	}
	fmt.Printf("%d\n", s)
	return true
}

func main() {
	if !run() {
		fail()
	}
}

#!/usr/bin/env python3
"""HTTP POST + JSON sum reference for AgentLang Index."""
import json
import sys
import urllib.error
import urllib.request


def main() -> int:
    try:
        lines = sys.stdin.read().splitlines()
        url = lines[0].strip()
        a = int(lines[1].strip())
        b = int(lines[2].strip())
    except (IndexError, ValueError, OSError):
        sys.stdout.write("error\n")
        return 0

    body = f'{{"a":{a},"b":{b}}}'.encode("ascii")
    req = urllib.request.Request(
        url,
        data=body,
        method="POST",
        headers={"Content-Type": "application/json"},
    )
    try:
        with urllib.request.urlopen(req, timeout=5) as resp:
            if resp.status != 200:
                sys.stdout.write("error\n")
                return 0
            response_body = resp.read()
    except urllib.error.HTTPError:
        sys.stdout.write("error\n")
        return 0
    except (urllib.error.URLError, ValueError, OSError, TimeoutError):
        sys.stdout.write("error\n")
        return 0

    try:
        parsed = json.loads(response_body.decode("utf-8"))
        if not isinstance(parsed, dict):
            raise ValueError
        s = parsed.get("sum")
        if not isinstance(s, int) or isinstance(s, bool):
            raise ValueError
        sys.stdout.write(f"{s}\n")
    except (json.JSONDecodeError, ValueError, UnicodeDecodeError):
        sys.stdout.write("error\n")
    return 0


if __name__ == "__main__":
    sys.exit(main())