const BASE  = "https://workspace.example.com";
const TOKEN = process.env.WORKSPACE_ENDPOINT_TOKEN;

async function callEndpoint(name, body, { timeoutMs = 120_000 } = {}) {
const url = `${BASE}/api/endpoints/token/run/${name}`;
const deadline = Date.now() + timeoutMs;
let retry = 0;

while (true) {
if (Date.now() > deadline) throw new Error(`endpoint ${name} timed out`);

const res = await fetch(url, {
method: "POST",
headers: {
Authorization:  `Bearer ${TOKEN}`,
"Content-Type": "application/json",
Accept:         "application/json",
"X-MSK-RETRY":  String(retry), // optional
},
body: JSON.stringify(body),
});

if (res.status === 202) {
const progress = res.headers.get("CalculationProgress");
if (progress) console.log(`progress: ${progress}`);
await new Promise(r => setTimeout(r, 1000));
retry++;
continue;
}

if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
return await res.json();
}
}

const results = await callEndpoint("similar-tickets", {
query:      "screen flicker after firmware update",
productSku: "PRO-14",
limit:      5,
});

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.time.Duration;

public class CuriosityClient {
private static final String BASE  = "https://workspace.example.com";
private static final String TOKEN = System.getenv("WORKSPACE_ENDPOINT_TOKEN");

public static String callEndpoint(String name, String jsonBody, Duration timeout) throws Exception {
var http     = HttpClient.newHttpClient();
var url      = URI.create(BASE + "/api/endpoints/token/run/" + name);
var deadline = System.nanoTime() + timeout.toNanos();
int retry    = 0;

while (true) {
if (System.nanoTime() > deadline)
throw new RuntimeException("endpoint " + name + " timed out");

var request = HttpRequest.newBuilder(url)
.header("Authorization", "Bearer " + TOKEN)
.header("Content-Type",  "application/json")
.header("Accept",        "application/json")
.header("X-MSK-RETRY",   Integer.toString(retry))   // optional
.POST(HttpRequest.BodyPublishers.ofString(jsonBody))
.build();

var response = http.send(request, BodyHandlers.ofString());

if (response.statusCode() == 202) {
response.headers().firstValue("CalculationProgress")
.ifPresent(p -> System.out.println("progress: " + p));
Thread.sleep(1000);
retry++;
continue;
}
if (response.statusCode() / 100 != 2)
throw new RuntimeException(response.statusCode() + " " + response.body());

return response.body();
}
}
}

package curiosity

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

func CallEndpoint(ctx context.Context, name string, body any, out any) error {
base  := "https://workspace.example.com"
token := os.Getenv("WORKSPACE_ENDPOINT_TOKEN")
url   := fmt.Sprintf("%s/api/endpoints/token/run/%s", base, name)

payload, err := json.Marshal(body)
if err != nil { return err }

client := &http.Client{Timeout: 30 * time.Second}
retry  := 0
for {
req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(payload))
if err != nil { return err }
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type",  "application/json")
req.Header.Set("Accept",        "application/json")
req.Header.Set("X-MSK-RETRY",   strconv.Itoa(retry)) // optional

resp, err := client.Do(req)
if err != nil { return err }

if resp.StatusCode == http.StatusAccepted {
if p := resp.Header.Get("CalculationProgress"); p != "" {
fmt.Println("progress:", p)
}
resp.Body.Close()
select {
case <-ctx.Done(): return ctx.Err()
case <-time.After(time.Second):
}
retry++
continue
}

defer resp.Body.Close()
if resp.StatusCode/100 != 2 {
return fmt.Errorf("endpoint %s: %s", name, resp.Status)
}
return json.NewDecoder(resp.Body).Decode(out)
}
}

use std::time::{Duration, Instant};
use serde::de::DeserializeOwned;
use serde::Serialize;

pub async fn call_endpoint<B: Serialize, T: DeserializeOwned>(
base: &str,
token: &str,
name: &str,
body: &B,
timeout: Duration,
) -> Result<T, Box<dyn std::error::Error>> {
let client   = reqwest::Client::new();
let url      = format!("{}/api/endpoints/token/run/{}", base.trim_end_matches('/'), name);
let deadline = Instant::now() + timeout;
let mut retry = 0u32;

loop {
if Instant::now() > deadline {
return Err(format!("endpoint {name} timed out").into());
}

let res = client.post(&url)
.bearer_auth(token)
.header("X-MSK-RETRY", retry.to_string())   // optional
.json(body)
.send().await?;

if res.status() == reqwest::StatusCode::ACCEPTED {
if let Some(p) = res.headers().get("CalculationProgress") {
if let Ok(s) = p.to_str() { println!("progress: {s}"); }
}
tokio::time::sleep(Duration::from_secs(1)).await;
retry += 1;
continue;
}

let res = res.error_for_status()?;
return Ok(res.json::<T>().await?);
}
}

#!/usr/bin/env bash
set -euo pipefail

BASE="https://workspace.example.com"
NAME="similar-tickets"
TOKEN="$WORKSPACE_ENDPOINT_TOKEN"
BODY='{"query":"screen flicker","productSku":"PRO-14","limit":5}'
URL="$BASE/api/endpoints/token/run/$NAME"

retry=0
while :; do
# -i prints headers + body; we want the status code separately.
http_status=$(curl -sS -o /tmp/resp.body -w '%{http_code}' \
-X POST "$URL" \
-H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
-H "X-MSK-RETRY: $retry" \
-d "$BODY")

case "$http_status" in
200) cat /tmp/resp.body; echo; exit 0 ;;
202) echo "still running..." >&2; sleep 1; retry=$((retry+1)) ;;
*)   echo "error $http_status:" >&2; cat /tmp/resp.body >&2; exit 1 ;;
esac
done