@xyd-js/opensdk-java 0.0.0-build-f0c10f6-20260703195526

package/__fixtures__/-2.complex.openai.full/output/src/main/java/com/example/openai/TranscriptionWord.java

@@ -0,0 +1,46 @@
+// Code generated by opensdk. DO NOT EDIT.
+
+package com.example.openai;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public final class TranscriptionWord implements Json.JsonSerializable {
+  private String word;
+  private Double start;
+  private Double end;
+
+  public String word() {
+    return word;
+  }
+
+  public Double start() {
+    return start;
+  }
+
+  public Double end() {
+    return end;
+  }
+
+  public static TranscriptionWord fromJson(Object json) {
+    if (json == null) {
+      return null;
+    }
+    @SuppressWarnings("unchecked")
+    Map<String, Object> map = (Map<String, Object>) json;
+    TranscriptionWord out = new TranscriptionWord();
+    out.word = Json.asString(map.get("word"));
+    out.start = Json.asDouble(map.get("start"));
+    out.end = Json.asDouble(map.get("end"));
+    return out;
+  }
+
+  @Override
+  public Map<String, Object> toJsonMap() {
+    Map<String, Object> map = new LinkedHashMap<>();
+    map.put("word", word);
+    map.put("start", start);
+    map.put("end", end);
+    return map;
+  }
+}

package/__fixtures__/-2.complex.openai.full/output/src/main/java/com/example/openai/Transport.java

@@ -0,0 +1,399 @@
+// Code generated by opensdk. DO NOT EDIT.
+
+package com.example.openai;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URLEncoder;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * The HTTP transport: builds the URL + query + headers, attaches the configured
+ * credential, encodes the request body (json / multipart / form), performs the
+ * request via {@link java.net.http.HttpClient} with a policy-driven retry loop
+ * (sdk.retry) and default timeout (sdk.timeout), and maps a non-2xx response to
+ * a status-mapped {@link ApiException}. Dependency-free — java.net.http + the
+ * Json codec only.
+ */
+public final class Transport {
+  private static final String DEFAULT_BASE_URL = "https://api.openai.com/v1";
+  private static final String USER_AGENT = userAgent();
+  private static final int MAX_RETRIES = 2;
+  private static final java.util.Set<Integer> RETRYABLE_STATUS_CODES = java.util.Set.of(408, 429, 500, 502, 503, 504);
+  private static final boolean RETRY_CONNECTION_ERRORS = true;
+  private static final boolean HONOR_RETRY_AFTER_HEADER = true;
+  private static final long BACKOFF_INITIAL_DELAY_MS = 500L;
+  private static final long BACKOFF_MAX_DELAY_MS = 8000L;
+  private static final double BACKOFF_MULTIPLIER = 2.0;
+  private static final double BACKOFF_JITTER = 0.25;
+  private static final String REQUEST_ID_HEADER = "X-Request-ID";
+  private static final long DEFAULT_TIMEOUT_MS = 60000L;
+
+  private final String baseUrl;
+  private final String apiKey;
+  private final HttpClient http;
+
+  public Transport(String baseUrl, String apiKey) {
+    this.baseUrl = (baseUrl == null || baseUrl.isEmpty()) ? DEFAULT_BASE_URL : baseUrl;
+    this.apiKey = apiKey;
+    this.http = HttpClient.newHttpClient();
+  }
+
+  /** The SDK User-Agent (sdk.userAgent): the identifier plus an AI-agent slug when a known env var is set. */
+  private static String userAgent() {
+    String ua = "openai-java/2.3.0";
+    String[][] agents = {
+      {"CLAUDE_CODE", "claude-code"},
+      {"CURSOR_AGENT", "cursor"},
+      {"CLINE_ACTIVE", "cline"},
+      {"WINDSURF_ACTIVE", "windsurf"},
+      {"COPILOT_AGENT", "copilot"},
+    };
+    for (String[] agent : agents) {
+      String value = System.getenv(agent[0]);
+      if (value != null && !value.isEmpty()) {
+        ua = ua + " agent/" + agent[1];
+        break;
+      }
+    }
+    return ua;
+  }
+
+  /** A single request, assembled by the generated service methods. */
+  public static final class Request {
+    final String method;
+    final String path;
+    final Map<String, List<String>> query = new LinkedHashMap<>();
+    final Map<String, String> headers = new LinkedHashMap<>();
+    Object body;
+    String encoding = "json";
+    String accept;
+
+    public Request(String method, String path) {
+      this.method = method;
+      this.path = path;
+    }
+
+    public Request query(String key, String value) {
+      query.computeIfAbsent(key, unused -> new ArrayList<>()).add(value);
+      return this;
+    }
+
+    public Request header(String key, String value) {
+      headers.put(key, value);
+      return this;
+    }
+
+    public Request body(Object value) {
+      this.body = value;
+      return this;
+    }
+
+    public Request encoding(String encoding) {
+      this.encoding = encoding;
+      return this;
+    }
+
+    public Request accept(String contentType) {
+      this.accept = contentType;
+      return this;
+    }
+  }
+
+  /** Perform the request and return the parsed JSON body (null for an empty body). */
+  public Object execute(Request request) {
+    HttpResponse<byte[]> response = send(request);
+    byte[] bytes = response.body();
+    if (bytes == null || bytes.length == 0) {
+      return null;
+    }
+    return Json.parse(new String(bytes, StandardCharsets.UTF_8));
+  }
+
+  /** Perform the request and return the raw response bytes (binary downloads). */
+  public byte[] executeRaw(Request request) {
+    return send(request).body();
+  }
+
+  private HttpResponse<byte[]> send(Request request) {
+    HttpRequest httpRequest = buildRequest(request);
+    int attempt = 0;
+    while (true) {
+      HttpResponse<byte[]> response;
+      try {
+        response = http.send(httpRequest, HttpResponse.BodyHandlers.ofByteArray());
+      } catch (java.io.IOException e) {
+        if (RETRY_CONNECTION_ERRORS && attempt < MAX_RETRIES) {
+          sleep(retryDelayMs(attempt, null));
+          attempt++;
+          continue;
+        }
+        throw new ApiException(0, "request failed: " + e.getMessage());
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+        throw new ApiException(0, "request interrupted: " + e.getMessage());
+      }
+      int status = response.statusCode();
+      if (status >= 400) {
+        if (attempt < MAX_RETRIES && RETRYABLE_STATUS_CODES.contains(status)) {
+          sleep(retryDelayMs(attempt, response));
+          attempt++;
+          continue;
+        }
+        byte[] body = response.body();
+        String requestId = response.headers().firstValue(REQUEST_ID_HEADER).orElse(null);
+        String message = errorMessage(body);
+        throw ApiException.of(status, message != null ? message : "HTTP " + status, body, requestId);
+      }
+      return response;
+    }
+  }
+
+  /** Assemble the immutable HttpRequest once (the body is encoded up front so retries replay the same bytes). */
+  private HttpRequest buildRequest(Request request) {
+    HttpRequest.Builder builder = HttpRequest.newBuilder().uri(URI.create(buildUrl(request)));
+    builder.header("User-Agent", USER_AGENT);
+    if (DEFAULT_TIMEOUT_MS > 0) {
+      builder.timeout(Duration.ofMillis(DEFAULT_TIMEOUT_MS));
+    }
+    if (request.accept != null) {
+      builder.header("Accept", request.accept);
+    }
+    for (Map.Entry<String, String> entry : request.headers.entrySet()) {
+      builder.header(entry.getKey(), entry.getValue());
+    }
+    if (apiKey != null) {
+      builder.header("Authorization", "Bearer " + apiKey);
+    }
+    if (request.body != null) {
+      byte[] payload;
+      String contentType;
+      switch (request.encoding) {
+        case "multipart": {
+          Multipart multipart = encodeMultipart(asMap(request.body));
+          payload = multipart.body;
+          contentType = multipart.contentType;
+          break;
+        }
+        case "form":
+          payload = encodeForm(asMap(request.body));
+          contentType = "application/x-www-form-urlencoded";
+          break;
+        default:
+          payload = Json.encode(request.body).getBytes(StandardCharsets.UTF_8);
+          contentType = "application/json";
+          break;
+      }
+      builder.header("Content-Type", contentType);
+      builder.method(request.method, HttpRequest.BodyPublishers.ofByteArray(payload));
+    } else {
+      builder.method(request.method, HttpRequest.BodyPublishers.noBody());
+    }
+    return builder.build();
+  }
+
+  /** The delay before the next retry attempt: Retry-After when honored, else jittered exponential backoff (sdk.retry). */
+  private static long retryDelayMs(int attempt, HttpResponse<byte[]> response) {
+    if (HONOR_RETRY_AFTER_HEADER && response != null) {
+      long retryAfter = retryAfterMs(response);
+      if (retryAfter >= 0) {
+        return retryAfter;
+      }
+    }
+    double delay = BACKOFF_INITIAL_DELAY_MS * Math.pow(BACKOFF_MULTIPLIER, attempt);
+    delay = Math.min(delay, BACKOFF_MAX_DELAY_MS);
+    return (long) (delay + delay * BACKOFF_JITTER * Math.random());
+  }
+
+  /** The Retry-After delay in millis (delta-seconds or HTTP-date, capped at 60s), or -1 if absent. */
+  private static long retryAfterMs(HttpResponse<byte[]> response) {
+    String value = response.headers().firstValue("Retry-After").orElse(null);
+    if (value == null) {
+      return -1;
+    }
+    value = value.trim();
+    try {
+      long seconds = Long.parseLong(value);
+      if (seconds >= 0) {
+        return Math.min(seconds * 1000L, 60000L);
+      }
+    } catch (NumberFormatException ignored) {
+      // not a delta-seconds value; try the HTTP-date form
+    }
+    try {
+      java.time.ZonedDateTime when = java.time.ZonedDateTime.parse(value, java.time.format.DateTimeFormatter.RFC_1123_DATE_TIME);
+      long wait = Duration.between(java.time.ZonedDateTime.now(), when).toMillis();
+      if (wait > 0) {
+        return Math.min(wait, 60000L);
+      }
+    } catch (java.time.format.DateTimeParseException ignored) {
+      // unparseable Retry-After; fall back to backoff
+    }
+    return -1;
+  }
+
+  private static void sleep(long millis) {
+    if (millis <= 0) {
+      return;
+    }
+    try {
+      Thread.sleep(millis);
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+    }
+  }
+
+  private String buildUrl(Request request) {
+    StringBuilder sb = new StringBuilder();
+    String trimmed = baseUrl.endsWith("/") ? baseUrl.substring(0, baseUrl.length() - 1) : baseUrl;
+    sb.append(trimmed);
+    sb.append(request.path.startsWith("/") ? request.path : "/" + request.path);
+    Map<String, List<String>> query = new LinkedHashMap<>(request.query);
+    if (!query.isEmpty()) {
+      sb.append('?');
+      boolean first = true;
+      for (Map.Entry<String, List<String>> entry : query.entrySet()) {
+        for (String value : entry.getValue()) {
+          sb.append(first ? "" : "&");
+          first = false;
+          sb.append(encodeQuery(entry.getKey())).append('=').append(encodeQuery(value));
+        }
+      }
+    }
+    return sb.toString();
+  }
+
+  /** URL-encode a path segment (spaces as %20, not '+'). */
+  public static String encodePath(String value) {
+    return URLEncoder.encode(value, StandardCharsets.UTF_8).replace("+", "%20");
+  }
+
+  private static String encodeQuery(String value) {
+    return URLEncoder.encode(value, StandardCharsets.UTF_8);
+  }
+
+  /** Best-effort message from a JSON error envelope ({"error": {"message": ...}} etc.). */
+  private static String errorMessage(byte[] body) {
+    if (body == null || body.length == 0) {
+      return null;
+    }
+    try {
+      Object parsed = Json.parse(new String(body, StandardCharsets.UTF_8));
+      if (parsed instanceof Map) {
+        Map<?, ?> map = (Map<?, ?>) parsed;
+        Object error = map.get("error");
+        if (error instanceof Map) {
+          Object message = ((Map<?, ?>) error).get("message");
+          if (message instanceof String) {
+            return (String) message;
+          }
+        }
+        if (error instanceof String) {
+          return (String) error;
+        }
+        for (String key : new String[] {"message", "detail"}) {
+          Object value = map.get(key);
+          if (value instanceof String) {
+            return (String) value;
+          }
+        }
+      }
+    } catch (RuntimeException ignored) {
+      // fall through to null
+    }
+    return null;
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, Object> asMap(Object value) {
+    return (Map<String, Object>) value;
+  }
+
+  /** application/x-www-form-urlencoded: repeated keys for list values, JSON for compound values. */
+  private static byte[] encodeForm(Map<String, Object> body) {
+    StringBuilder sb = new StringBuilder();
+    for (Map.Entry<String, Object> entry : body.entrySet()) {
+      Object value = entry.getValue();
+      if (value instanceof Iterable) {
+        for (Object item : (Iterable<?>) value) {
+          appendForm(sb, entry.getKey(), item);
+        }
+      } else {
+        appendForm(sb, entry.getKey(), value);
+      }
+    }
+    return sb.toString().getBytes(StandardCharsets.UTF_8);
+  }
+
+  private static void appendForm(StringBuilder sb, String key, Object value) {
+    if (sb.length() > 0) {
+      sb.append('&');
+    }
+    sb.append(encodeQuery(key)).append('=').append(encodeQuery(formValue(value)));
+  }
+
+  private static String formValue(Object value) {
+    if (value instanceof byte[]) {
+      return new String((byte[]) value, StandardCharsets.UTF_8);
+    }
+    if (value instanceof Map || value instanceof Iterable) {
+      return Json.encode(value);
+    }
+    return String.valueOf(value);
+  }
+
+  /** A hand-built multipart/form-data body: byte[] values become file parts, everything else a field. */
+  private static Multipart encodeMultipart(Map<String, Object> body) {
+    String boundary = "----opensdk" + UUID.randomUUID().toString().replace("-", "");
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    try {
+      for (Map.Entry<String, Object> entry : body.entrySet()) {
+        Object value = entry.getValue();
+        if (value instanceof Iterable) {
+          for (Object item : (Iterable<?>) value) {
+            writePart(out, boundary, entry.getKey(), item);
+          }
+        } else {
+          writePart(out, boundary, entry.getKey(), value);
+        }
+      }
+      out.write(("--" + boundary + "--\r\n").getBytes(StandardCharsets.UTF_8));
+    } catch (IOException e) {
+      throw new ApiException(0, "multipart encoding failed: " + e.getMessage());
+    }
+    return new Multipart(out.toByteArray(), "multipart/form-data; boundary=" + boundary);
+  }
+
+  private static void writePart(ByteArrayOutputStream out, String boundary, String name, Object value) throws IOException {
+    out.write(("--" + boundary + "\r\n").getBytes(StandardCharsets.UTF_8));
+    if (value instanceof byte[]) {
+      out.write(("Content-Disposition: form-data; name=\"" + name + "\"; filename=\"" + name + "\"\r\n").getBytes(StandardCharsets.UTF_8));
+      out.write("Content-Type: application/octet-stream\r\n\r\n".getBytes(StandardCharsets.UTF_8));
+      out.write((byte[]) value);
+    } else {
+      out.write(("Content-Disposition: form-data; name=\"" + name + "\"\r\n\r\n").getBytes(StandardCharsets.UTF_8));
+      out.write(formValue(value).getBytes(StandardCharsets.UTF_8));
+    }
+    out.write("\r\n".getBytes(StandardCharsets.UTF_8));
+  }
+
+  private static final class Multipart {
+    final byte[] body;
+    final String contentType;
+
+    Multipart(byte[] body, String contentType) {
+      this.body = body;
+      this.contentType = contentType;
+    }
+  }
+}

package/__fixtures__/-2.complex.openai.full/output/src/main/java/com/example/openai/TruncationEnum.java

@@ -0,0 +1,36 @@
+// Code generated by opensdk. DO NOT EDIT.
+
+package com.example.openai;
+
+public enum TruncationEnum implements Json.JsonEnum {
+  AUTO("auto"),
+  DISABLED("disabled");
+
+  private final String value;
+
+  TruncationEnum(String value) {
+    this.value = value;
+  }
+
+  public String value() {
+    return value;
+  }
+
+  @Override
+  public Object jsonValue() {
+    return value;
+  }
+
+  public static TruncationEnum fromValue(String value) {
+    for (TruncationEnum item : values()) {
+      if (item.value.equals(value)) {
+        return item;
+      }
+    }
+    throw new IllegalArgumentException("unknown TruncationEnum value: " + value);
+  }
+
+  public static TruncationEnum fromJson(Object json) {
+    return json == null ? null : fromValue(Json.asString(json));
+  }
+}

package/__fixtures__/-2.complex.openai.full/output/src/main/java/com/example/openai/TruncationObject.java

@@ -0,0 +1,42 @@
+// Code generated by opensdk. DO NOT EDIT.
+
+package com.example.openai;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/** Controls for how a thread will be truncated prior to the run. Use this to control the initial context window of the run. */
+public final class TruncationObject implements Json.JsonSerializable {
+  private TruncationObjectType type;
+  private Long lastMessages;
+
+  public TruncationObjectType type() {
+    return type;
+  }
+
+  public Long lastMessages() {
+    return lastMessages;
+  }
+
+  public static TruncationObject fromJson(Object json) {
+    if (json == null) {
+      return null;
+    }
+    @SuppressWarnings("unchecked")
+    Map<String, Object> map = (Map<String, Object>) json;
+    TruncationObject out = new TruncationObject();
+    out.type = TruncationObjectType.fromJson(map.get("type"));
+    out.lastMessages = Json.asLong(map.get("last_messages"));
+    return out;
+  }
+
+  @Override
+  public Map<String, Object> toJsonMap() {
+    Map<String, Object> map = new LinkedHashMap<>();
+    map.put("type", type);
+    if (lastMessages != null) {
+      map.put("last_messages", lastMessages);
+    }
+    return map;
+  }
+}

package/__fixtures__/-2.complex.openai.full/output/src/main/java/com/example/openai/TruncationObjectType.java

@@ -0,0 +1,37 @@
+// Code generated by opensdk. DO NOT EDIT.
+
+package com.example.openai;
+
+/** The truncation strategy to use for the thread. The default is `auto`. If set to `last_messages`, the thread will be truncated to the n most recent messages in the thread. When set to `auto`, messages in the middle of the thread will be dropped to fit the context length of the model, `max_prompt_tokens`. */
+public enum TruncationObjectType implements Json.JsonEnum {
+  AUTO("auto"),
+  LAST_MESSAGES("last_messages");
+
+  private final String value;
+
+  TruncationObjectType(String value) {
+    this.value = value;
+  }
+
+  public String value() {
+    return value;
+  }
+
+  @Override
+  public Object jsonValue() {
+    return value;
+  }
+
+  public static TruncationObjectType fromValue(String value) {
+    for (TruncationObjectType item : values()) {
+      if (item.value.equals(value)) {
+        return item;
+      }
+    }
+    throw new IllegalArgumentException("unknown TruncationObjectType value: " + value);
+  }
+
+  public static TruncationObjectType fromJson(Object json) {
+    return json == null ? null : fromValue(Json.asString(json));
+  }
+}

package/__fixtures__/-2.complex.openai.full/output/src/main/java/com/example/openai/TypeParam.java

@@ -0,0 +1,40 @@
+// Code generated by opensdk. DO NOT EDIT.
+
+package com.example.openai;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/** An action to type in text. */
+public final class TypeParam implements Json.JsonSerializable {
+  private String type;
+  private String text;
+
+  public String type() {
+    return type;
+  }
+
+  public String text() {
+    return text;
+  }
+
+  public static TypeParam fromJson(Object json) {
+    if (json == null) {
+      return null;
+    }
+    @SuppressWarnings("unchecked")
+    Map<String, Object> map = (Map<String, Object>) json;
+    TypeParam out = new TypeParam();
+    out.type = Json.asString(map.get("type"));
+    out.text = Json.asString(map.get("text"));
+    return out;
+  }
+
+  @Override
+  public Map<String, Object> toJsonMap() {
+    Map<String, Object> map = new LinkedHashMap<>();
+    map.put("type", type != null ? type : "type");
+    map.put("text", text);
+    return map;
+  }
+}

package/__fixtures__/-2.complex.openai.full/output/src/main/java/com/example/openai/UnauthorizedException.java

@@ -0,0 +1,10 @@
+// Code generated by opensdk. DO NOT EDIT.
+
+package com.example.openai;
+
+/** The "Unauthorized" error kind (HTTP 401 responses). */
+public final class UnauthorizedException extends ApiException {
+  public UnauthorizedException(int statusCode, String message, byte[] rawBody, String requestId) {
+    super(statusCode, message, rawBody, requestId, "Unauthorized");
+  }
+}

package/__fixtures__/-2.complex.openai.full/output/src/main/java/com/example/openai/UnprocessableEntityException.java

@@ -0,0 +1,10 @@
+// Code generated by opensdk. DO NOT EDIT.
+
+package com.example.openai;
+
+/** The "UnprocessableEntity" error kind (HTTP 422 responses). */
+public final class UnprocessableEntityException extends ApiException {
+  public UnprocessableEntityException(int statusCode, String message, byte[] rawBody, String requestId) {
+    super(statusCode, message, rawBody, requestId, "UnprocessableEntity");
+  }
+}

package/__fixtures__/-2.complex.openai.full/output/src/main/java/com/example/openai/UpdateConversationBody.java

@@ -0,0 +1,32 @@
+// Code generated by opensdk. DO NOT EDIT.
+
+package com.example.openai;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public final class UpdateConversationBody implements Json.JsonSerializable {
+  private Map<String, String> metadata;
+
+  public Map<String, String> metadata() {
+    return metadata;
+  }
+
+  public static UpdateConversationBody fromJson(Object json) {
+    if (json == null) {
+      return null;
+    }
+    @SuppressWarnings("unchecked")
+    Map<String, Object> map = (Map<String, Object>) json;
+    UpdateConversationBody out = new UpdateConversationBody();
+    out.metadata = Json.mapValues(map.get("metadata"), __e -> Json.asString(__e));
+    return out;
+  }
+
+  @Override
+  public Map<String, Object> toJsonMap() {
+    Map<String, Object> map = new LinkedHashMap<>();
+    map.put("metadata", metadata);
+    return map;
+  }
+}

package/__fixtures__/-2.complex.openai.full/output/src/main/java/com/example/openai/UpdateGroupBody.java

@@ -0,0 +1,33 @@
+// Code generated by opensdk. DO NOT EDIT.
+
+package com.example.openai;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/** Request payload for updating the details of an existing group. */
+public final class UpdateGroupBody implements Json.JsonSerializable {
+  private String name;
+
+  public String name() {
+    return name;
+  }
+
+  public static UpdateGroupBody fromJson(Object json) {
+    if (json == null) {
+      return null;
+    }
+    @SuppressWarnings("unchecked")
+    Map<String, Object> map = (Map<String, Object>) json;
+    UpdateGroupBody out = new UpdateGroupBody();
+    out.name = Json.asString(map.get("name"));
+    return out;
+  }
+
+  @Override
+  public Map<String, Object> toJsonMap() {
+    Map<String, Object> map = new LinkedHashMap<>();
+    map.put("name", name);
+    return map;
+  }
+}