MiniMax H3 Max — Recast

// Node.js 18+. Save your customized input in input.json.
import { readFileSync } from 'node:fs';
import { randomUUID } from 'node:crypto';
const base = process.env.WEBOT_BASE_URL.replace(/\/$/, '');
const key = process.env.WEBOT_API_KEY;
const input = JSON.parse(readFileSync('input.json', 'utf8'));
const nonce = process.env.WEBOT_JOB_NONCE || randomUUID(); // Persist before submission.
async function post(path, body, nonce) {
  const response = await fetch(base + path, {method:'POST', headers:{
    Authorization:`Bearer ${key}`, 'Content-Type':'application/json',
    ...(nonce ? {'Idempotency-Key':nonce} : {})}, body:JSON.stringify(body)});
  const json = await response.json();
  if (!response.ok) throw new Error(JSON.stringify(json));
  return json;
}
const {quote} = await post('/api/v1/models/minimax_h3_max_recast/quote', {input});
const job = await post('/api/v1/models/minimax_h3_max_recast/requests', {input, quoted_credits:quote.credits_consumed}, nonce);
console.log(job); // Stable WEBOT request_id, events_url, result_url.
// Stream saved webhook state. Reconnect ONLY the event stream, not the generation.
while (!job.terminal || job.financial_pending) {
  const stream = await fetch(job.events_url, {headers:{Authorization:`Bearer ${key}`}});
  if (!stream.ok) throw new Error(`Event stream HTTP ${stream.status}`);
  let buffer = '';
  for await (const chunk of stream.body.pipeThrough(new TextDecoderStream())) {
    buffer += chunk;
    let end;
    while ((end = buffer.indexOf('\n\n')) !== -1) {
      const event = buffer.slice(0, end); buffer = buffer.slice(end + 2);
      const data = event.split('\n').find(line => line.startsWith('data: '));
      if (!data) continue;
      const state = JSON.parse(data.slice(6));
      if (state.error && !state.status) throw new Error(JSON.stringify(state.error));
      if (state.terminal && !state.financial_pending) { console.log(state.output ?? state.error); process.exit(0); }
    }
  }
  await new Promise(resolve => setTimeout(resolve, 1500));
}
console.log(job.output ?? job.error);

// Node.js 18+. Save your customized input in input.json.
import { readFileSync } from 'node:fs';
import { randomUUID } from 'node:crypto';
const base = process.env.WEBOT_BASE_URL!.replace(/\/$/, '');
const key = process.env.WEBOT_API_KEY!;
const input = JSON.parse(readFileSync('input.json', 'utf8'));
const nonce = process.env.WEBOT_JOB_NONCE || randomUUID(); // Persist before submission.
async function post(path: string, body: unknown, nonce?: string) {
  const response = await fetch(base + path, {method:'POST', headers:{
    Authorization:`Bearer ${key}`, 'Content-Type':'application/json',
    ...(nonce ? {'Idempotency-Key':nonce} : {})}, body:JSON.stringify(body)});
  const json = await response.json();
  if (!response.ok) throw new Error(JSON.stringify(json));
  return json;
}
const {quote} = await post('/api/v1/models/minimax_h3_max_recast/quote', {input});
const job = await post('/api/v1/models/minimax_h3_max_recast/requests', {input, quoted_credits:quote.credits_consumed}, nonce);
console.log(job); // Stable WEBOT request_id, events_url, result_url.
// Stream saved webhook state. Reconnect ONLY the event stream, not the generation.
while (!job.terminal || job.financial_pending) {
  const stream = await fetch(job.events_url, {headers:{Authorization:`Bearer ${key}`}});
  if (!stream.ok) throw new Error(`Event stream HTTP ${stream.status}`);
  let buffer = '';
  for await (const chunk of stream.body.pipeThrough(new TextDecoderStream())) {
    buffer += chunk;
    let end;
    while ((end = buffer.indexOf('\n\n')) !== -1) {
      const event = buffer.slice(0, end); buffer = buffer.slice(end + 2);
      const data = event.split('\n').find(line => line.startsWith('data: '));
      if (!data) continue;
      const state = JSON.parse(data.slice(6));
      if (state.error && !state.status) throw new Error(JSON.stringify(state.error));
      if (state.terminal && !state.financial_pending) { console.log(state.output ?? state.error); process.exit(0); }
    }
  }
  await new Promise(resolve => setTimeout(resolve, 1500));
}
console.log(job.output ?? job.error);

# Python 3.9+, pip install requests
import json, os, time, uuid, requests
base = os.environ['WEBOT_BASE_URL'].rstrip('/')
headers = {'Authorization': 'Bearer ' + os.environ['WEBOT_API_KEY']}
with open('input.json', encoding='utf-8') as file:
    input_data = json.load(file)
nonce = os.environ.get('WEBOT_JOB_NONCE') or str(uuid.uuid4()) # Persist before submitting.
def post(path, body, extra=None):
    response = requests.post(base + path, headers={**headers, **(extra or {})}, json=body, timeout=180)
    response.raise_for_status()
    return response.json()
quote = post('/api/v1/models/minimax_h3_max_recast/quote', {'input': input_data})['quote']
job = post('/api/v1/models/minimax_h3_max_recast/requests', {'input': input_data, 'quoted_credits': quote['credits_consumed']}, {'Idempotency-Key': nonce})
state = job
while not state['terminal'] or state.get('financial_pending', False):
    # Reconnect while nonterminal; this reads WEBOT's database, never a provider status API.
    with requests.get(job['events_url'], headers=headers, stream=True, timeout=(10, 40)) as stream:
        stream.raise_for_status()
        for line in stream.iter_lines(decode_unicode=True):
            if line and line.startswith('data: '):
                state = json.loads(line[6:])
                if 'status' not in state: raise RuntimeError(state)
                if state['terminal'] and not state.get('financial_pending', False): break
    if not state['terminal'] or state.get('financial_pending', False): time.sleep(1.5)
print(state['output'] if state['status'] == 'completed' else state['error'])

<?php // PHP 8.1+ with cURL
$base = rtrim(getenv('WEBOT_BASE_URL'), '/');
$input = json_decode(file_get_contents('input.json'), false, 64, JSON_THROW_ON_ERROR);
$nonce = getenv('WEBOT_JOB_NONCE') ?: bin2hex(random_bytes(16)); // Persist this before submission.
function post(string $path, array $body, ?string $nonce = null): array {
    global $base;
    $headers = ['Authorization: Bearer '.getenv('WEBOT_API_KEY'), 'Content-Type: application/json'];
    if ($nonce) $headers[] = 'Idempotency-Key: '.$nonce;
    $ch = curl_init($base.$path);
    curl_setopt_array($ch, [CURLOPT_RETURNTRANSFER=>true, CURLOPT_POST=>true,
        CURLOPT_TIMEOUT=>180, CURLOPT_HTTPHEADER=>$headers,
        CURLOPT_POSTFIELDS=>json_encode($body, JSON_THROW_ON_ERROR)]);
    $raw = curl_exec($ch); $status = curl_getinfo($ch, CURLINFO_HTTP_CODE); curl_close($ch);
    if ($raw === false || $status < 200 || $status >= 300) throw new RuntimeException('WEBOT HTTP '.$status);
    return json_decode($raw, true, 64, JSON_THROW_ON_ERROR);
}
$quote = post('/api/v1/models/minimax_h3_max_recast/quote', ['input'=>$input])['quote'];
$job = post('/api/v1/models/minimax_h3_max_recast/requests', ['input'=>$input, 'quoted_credits'=>$quote['credits_consumed']], $nonce);
echo json_encode($job, JSON_PRETTY_PRINT); // Connect to events_url with the same Bearer header.

// Go 1.20+; save as main.go.
package main
import ("bytes"; "encoding/json"; "fmt"; "io"; "net/http"; "os"; "strings"; "time"; "crypto/rand"; "encoding/hex")
func main() {
    base := strings.TrimRight(os.Getenv("WEBOT_BASE_URL"), "/")
    raw, err := os.ReadFile("input.json"); if err != nil { panic(err) }
    nonce := os.Getenv("WEBOT_JOB_NONCE")
    if nonce == "" { b := make([]byte,16); if _,err:=rand.Read(b);err!=nil {panic(err)}; nonce=hex.EncodeToString(b) }
    // Persist nonce before the submission; reuse on ambiguous responses.
    client := &http.Client{Timeout:180*time.Second}
    post := func(path string, body any, id string) map[string]any {
        data, err := json.Marshal(body); if err != nil {panic(err)}
        req, err := http.NewRequest("POST",base+path,bytes.NewReader(data)); if err!=nil {panic(err)}
        req.Header.Set("Authorization","Bearer "+os.Getenv("WEBOT_API_KEY")); req.Header.Set("Content-Type","application/json")
        if id!="" {req.Header.Set("Idempotency-Key",id)}
        res,err:=client.Do(req); if err!=nil {panic(err)}; defer res.Body.Close()
        data,err=io.ReadAll(res.Body); if err!=nil {panic(err)}
        if res.StatusCode<200||res.StatusCode>=300 {panic(string(data))}
        var result map[string]any; if err=json.Unmarshal(data,&result);err!=nil {panic(err)}; return result
    }
    input:=json.RawMessage(raw)
    quote:=post("/api/v1/models/minimax_h3_max_recast/quote",map[string]any{"input":input},"")["quote"].(map[string]any)
    job:=post("/api/v1/models/minimax_h3_max_recast/requests",map[string]any{"input":input,"quoted_credits":quote["credits_consumed"]},nonce)
    fmt.Println(job) // Stream events_url with the same Authorization header.
}

// Java 11+, Jackson databind dependency; class Main in Main.java.
import java.net.URI;
import java.net.http.*;
import java.nio.file.*;
import java.time.Duration;
import java.util.UUID;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.node.ObjectNode;
public class Main {
  static final ObjectMapper json = new ObjectMapper();
  static final HttpClient client = HttpClient.newHttpClient();
  static final String base = System.getenv("WEBOT_BASE_URL").replaceAll("/$", "");
  static JsonNode post(String path, JsonNode body, String nonce) throws Exception {
    var b = HttpRequest.newBuilder(URI.create(base+path)).timeout(Duration.ofSeconds(180))
      .header("Authorization","Bearer "+System.getenv("WEBOT_API_KEY")).header("Content-Type","application/json")
      .POST(HttpRequest.BodyPublishers.ofString(json.writeValueAsString(body)));
    if(nonce!=null)b.header("Idempotency-Key",nonce);
    var r=client.send(b.build(),HttpResponse.BodyHandlers.ofString());
    if(r.statusCode()<200||r.statusCode()>=300)throw new IllegalStateException(r.body());
    return json.readTree(r.body());
  }
  public static void main(String[] args) throws Exception {
    var input=json.readTree(Files.readString(Path.of("input.json")));
    ObjectNode body=json.createObjectNode();body.set("input",input);
    var quote=post("/api/v1/models/minimax_h3_max_recast/quote",body,null).get("quote");
    body.put("quoted_credits",quote.get("credits_consumed").asInt());
    String nonce=System.getenv("WEBOT_JOB_NONCE");if(nonce==null)nonce=UUID.randomUUID().toString(); // Persist before POST.
    var job=post("/api/v1/models/minimax_h3_max_recast/requests",body,nonce);System.out.println(job);
    // Subscribe to job.events_url with Authorization; use BodyHandlers.ofLines().
  }
}

// .NET 8 console app, top-level statements.
using System.Net.Http;
using System.Text;
using System.Text.Json.Nodes;
var client = new HttpClient { Timeout = TimeSpan.FromSeconds(180) };
var root = Environment.GetEnvironmentVariable("WEBOT_BASE_URL")!.TrimEnd('/');
var key = Environment.GetEnvironmentVariable("WEBOT_API_KEY");
async Task<JsonNode> Post(string path, JsonNode body, string? nonce = null) {
    using var req = new HttpRequestMessage(HttpMethod.Post, root + path);
    req.Headers.Add("Authorization", "Bearer " + key);
    if (nonce != null) req.Headers.Add("Idempotency-Key", nonce);
    req.Content = new StringContent(body.ToJsonString(), Encoding.UTF8, "application/json");
    using var res = await client.SendAsync(req);
    var raw = await res.Content.ReadAsStringAsync();res.EnsureSuccessStatusCode();
    return JsonNode.Parse(raw)!;
}
var input = JsonNode.Parse(await File.ReadAllTextAsync("input.json"));
var body = new JsonObject { ["input"] = input };
var quote = await Post("/api/v1/models/minimax_h3_max_recast/quote", body);
body["quoted_credits"] = quote["quote"]!["credits_consumed"]!.GetValue<int>();
var nonce = Environment.GetEnvironmentVariable("WEBOT_JOB_NONCE") ?? Guid.NewGuid().ToString(); // Persist before submitting.
var job = await Post("/api/v1/models/minimax_h3_max_recast/requests", body, nonce);
Console.WriteLine(job); // Subscribe to events_url with the same Bearer header and ResponseHeadersRead.

# Ruby 3+, standard library only.
require 'net/http'
require 'json'
require 'securerandom'
base = ENV.fetch('WEBOT_BASE_URL').sub(%r{/$}, '')
post = lambda do |path, body, nonce = nil|
  uri = URI(base + path)
  req = Net::HTTP::Post.new(uri)
  req['Authorization'] = 'Bearer ' + ENV.fetch('WEBOT_API_KEY')
  req['Content-Type'] = 'application/json'
  req['Idempotency-Key'] = nonce if nonce
  req.body = JSON.generate(body)
  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 180) { |http| http.request(req) }
  raise res.body unless res.is_a?(Net::HTTPSuccess)
  JSON.parse(res.body)
end
input = JSON.parse(File.read('input.json'))
quote = post.call('/api/v1/models/minimax_h3_max_recast/quote', {'input' => input})['quote']
nonce = ENV['WEBOT_JOB_NONCE'] || SecureRandom.uuid # Persist this before submission.
job = post.call('/api/v1/models/minimax_h3_max_recast/requests', {'input' => input, 'quoted_credits' => quote['credits_consumed']}, nonce)
puts JSON.pretty_generate(job) # Subscribe to events_url with the same Authorization header.

// Swift 5.9 server-side/CLI only. Do not embed customer keys in shipped apps.
import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
@main struct Main {
 static func main() async throws {
  let env=ProcessInfo.processInfo.environment
  let base=env["WEBOT_BASE_URL"]!.trimmingCharacters(in: CharacterSet(charactersIn:"/"))
  let input=try JSONSerialization.jsonObject(with: Data(contentsOf:URL(fileURLWithPath:"input.json")))
  func post(_ path:String,_ body:[String:Any],_ nonce:String?=nil) async throws -> [String:Any] {
   var req=URLRequest(url:URL(string:base+path)!);req.httpMethod="POST";req.timeoutInterval=180
   req.setValue("Bearer "+env["WEBOT_API_KEY"]!,forHTTPHeaderField:"Authorization")
   req.setValue("application/json",forHTTPHeaderField:"Content-Type")
   if let nonce {req.setValue(nonce,forHTTPHeaderField:"Idempotency-Key")}
   req.httpBody=try JSONSerialization.data(withJSONObject:body)
   let (data,res)=try await URLSession.shared.data(for:req)
   guard let http=res as? HTTPURLResponse,(200..<300).contains(http.statusCode) else {throw NSError(domain:"WEBOT",code:1)}
   return try JSONSerialization.jsonObject(with:data) as! [String:Any]
  }
  let quote=try await post("/api/v1/models/minimax_h3_max_recast/quote",["input":input])["quote"] as! [String:Any]
  let nonce=env["WEBOT_JOB_NONCE"] ?? UUID().uuidString // Persist before submission.
  let job=try await post("/api/v1/models/minimax_h3_max_recast/requests",["input":input,"quoted_credits":quote["credits_consumed"]!],nonce)
  print(job) // Subscribe to events_url with the same Authorization header.
 }
}

// Server-side Kotlin/JVM 17+, Gradle dependencies: OkHttp 4.12, org.json 20240303.
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import java.io.File
import java.util.UUID
import java.util.concurrent.TimeUnit
fun main() {
 val base=System.getenv("WEBOT_BASE_URL").trimEnd('/')
 val client=OkHttpClient.Builder().readTimeout(180,TimeUnit.SECONDS).build()
 fun post(path:String,body:JSONObject,nonce:String?=null):JSONObject {
  val b=Request.Builder().url(base+path).header("Authorization","Bearer "+System.getenv("WEBOT_API_KEY"))
   .post(body.toString().toRequestBody("application/json".toMediaType()))
  if(nonce!=null)b.header("Idempotency-Key",nonce)
  return client.newCall(b.build()).execute().use {res ->
   val raw=res.body!!.string();check(res.isSuccessful){raw};JSONObject(raw)
  }
 }
 val body=JSONObject().put("input",JSONObject(File("input.json").readText()))
 val quote=post("/api/v1/models/minimax_h3_max_recast/quote",body).getJSONObject("quote")
 body.put("quoted_credits",quote.getInt("credits_consumed"))
 val nonce=System.getenv("WEBOT_JOB_NONCE") ?: UUID.randomUUID().toString() // Persist before submission.
 val job=post("/api/v1/models/minimax_h3_max_recast/requests",body,nonce)
 println(job) // Subscribe to events_url with the same Authorization header.
}