@superlinked/sie-sdk 0.3.0 → 0.3.2

package/dist/index.cjs

@@ -87,6 +87,28 @@ var ModelLoadingError = class extends SIEError {
     this.model = model;
   }
 };
+var ModelLoadFailedError = class extends ServerError {
+  /** The model that was requested */
+  model;
+  /**
+   * Server-side classification: one of `GATED`, `OOM`, `DEPENDENCY`,
+   * `NOT_FOUND`, `NETWORK`, `UNKNOWN`. Use this to route to specific
+   * remediation paths (e.g. surface a "set HF_TOKEN" hint for `GATED`).
+   */
+  errorClass;
+  /** Whether the failure is non-retryable per server policy. */
+  permanent;
+  /** How many load attempts the server has logged. */
+  attempts;
+  constructor(message, options) {
+    super(message, "MODEL_LOAD_FAILED", 502);
+    this.name = "ModelLoadFailedError";
+    this.model = options?.model;
+    this.errorClass = options?.errorClass;
+    this.permanent = options?.permanent ?? true;
+    this.attempts = options?.attempts ?? 1;
+  }
+};
 
 // src/internal/constants.ts
 var MSGPACK_CONTENT_TYPE = "application/msgpack";
@@ -311,7 +333,7 @@ function getRetryAfter2(response) {
   const header = response.headers.get("Retry-After");
   return getRetryAfter(header);
 }
-async function getErrorCode(response) {
+async function getErrorDetail(response) {
   try {
     const contentType = response.headers.get("content-type") ?? "";
     let data;
@@ -322,40 +344,73 @@ async function getErrorCode(response) {
       data = await response.json();
     }
     if (data.error && typeof data.error === "object") {
-      const error = data.error;
-      if (typeof error.code === "string") {
-        return error.code;
-      }
+      return data.error;
     }
     if (data.detail && typeof data.detail === "object") {
-      const detail = data.detail;
-      if (typeof detail.code === "string") {
-        return detail.code;
-      }
+      return data.detail;
     }
     if (typeof data.code === "string") {
-      return data.code;
+      return data;
     }
   } catch {
   }
   return void 0;
 }
+async function getErrorCode(response) {
+  const detail = await getErrorDetail(response);
+  if (!detail) return void 0;
+  const code = detail.code;
+  return typeof code === "string" ? code : void 0;
+}
+async function throwIfModelLoadFailed(response, model) {
+  if (response.status !== 502) return;
+  const detail = await getErrorDetail(response.clone());
+  if (!detail) return;
+  if (detail.code !== "MODEL_LOAD_FAILED") return;
+  const errorClass = typeof detail.error_class === "string" ? detail.error_class : void 0;
+  const permanent = typeof detail.permanent === "boolean" ? detail.permanent : true;
+  const attemptsRaw = detail.attempts;
+  const parsedAttempts = typeof attemptsRaw === "number" ? attemptsRaw : typeof attemptsRaw === "string" ? Number.parseInt(attemptsRaw, 10) : Number.NaN;
+  const attempts = Number.isFinite(parsedAttempts) ? parsedAttempts : 1;
+  const message = typeof detail.message === "string" ? detail.message : `Model '${model ?? "?"}' failed to load`;
+  throw new ModelLoadFailedError(message, {
+    model,
+    errorClass,
+    permanent,
+    attempts
+  });
+}
 async function handleError(response, gpu) {
   const { status } = response;
-  let errorBody = {};
-  try {
-    errorBody = await response.json();
-  } catch {
+  const detail = await getErrorDetail(response.clone());
+  let code;
+  let message;
+  if (detail) {
+    const c = detail.code;
+    code = typeof c === "string" ? c : void 0;
+    const m = detail.message;
+    message = typeof m === "string" ? m : JSON.stringify(detail);
+  } else {
+    try {
+      const data = await response.json();
+      if (typeof data.detail === "string") {
+        code = typeof data.code === "string" ? data.code : void 0;
+        message = data.detail;
+      } else if (typeof data.message === "string") {
+        code = typeof data.code === "string" ? data.code : void 0;
+        message = data.message;
+      } else {
+        code = typeof data.code === "string" ? data.code : void 0;
+        message = response.statusText;
+      }
+    } catch {
+      code = void 0;
+      message = response.statusText;
+    }
   }
-  const code = errorBody.code ?? "UNKNOWN";
-  const message = errorBody.detail ?? response.statusText;
   if (status === HTTP_ACCEPTED) {
-    const retryAfter = response.headers.get("Retry-After");
-    throw new ProvisioningError(
-      message,
-      gpu,
-      retryAfter ? Number.parseInt(retryAfter, 10) * 1e3 : void 0
-    );
+    const retryAfter = getRetryAfter2(response);
+    throw new ProvisioningError(message, gpu, retryAfter);
   }
   if (status >= HTTP_CLIENT_ERROR_MIN && status <= HTTP_CLIENT_ERROR_MAX) {
     throw new RequestError(message, code, status);
@@ -476,7 +531,7 @@ function parseCapacityInfo(data, gpuFilter) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.3.0";
+var SDK_VERSION = "0.3.2";
 
 // src/client.ts
 function sleep(ms) {
@@ -1180,6 +1235,7 @@ var SIEClient = class {
         await sleep(actualDelay);
         continue;
       }
+      await throwIfModelLoadFailed(response, model);
       if (response.status === 503) {
         const clonedResponse = response.clone();
         const errorCode = await getErrorCode(clonedResponse);
@@ -1502,6 +1558,7 @@ function detectImageFormat(bytes) {
 }
 
 exports.LoraLoadingError = LoraLoadingError;
+exports.ModelLoadFailedError = ModelLoadFailedError;
 exports.ModelLoadingError = ModelLoadingError;
 exports.PoolError = PoolError;
 exports.ProvisioningError = ProvisioningError;