@hypit/hypit 0.2.10 → 0.2.12

package/README.md

@@ -17,7 +17,11 @@
 
 <p align="center">
   <a href="https://trendshift.io/repositories/229030"><img alt="Trendshift #1 Repository of the Day" src="https://trendshift.io/api/badge/trendshift/repositories/229030/daily"></a>
+</p>
+
+<p align="center">
   <a href="https://trendshift.io/repositories/229030"><img alt="Trendshift #1 TypeScript Repository of the Day" src="https://trendshift.io/api/badge/trendshift/repositories/229030/daily?language=TypeScript"></a>
+  <a href="https://trendshift.io/repositories/229030?utm_source=trendshift-badge&amp;utm_medium=badge&amp;utm_campaign=badge-trendshift-229030" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/trendshift/repositories/229030/weekly?language=TypeScript" alt="hypit-ai/hypit | Trendshift TypeScript Weekly" width="250" height="55"></a>
 </p>
 
 <p align="center">
@@ -154,14 +158,14 @@ commands and the repository layout.
 <table>
   <tr>
     <td width="220" align="center">
-      <a href="https://watcha.cn">
+      <a href="https://watcha.cn/r/geIiJJ">
         <picture>
           <source media="(prefers-color-scheme: dark)" srcset="./docs/public/watcha-dark.png">
           <img alt="Watcha" src="./docs/public/watcha-light.png" width="170">
         </picture>
       </a>
     </td>
-    <td><a href="https://watcha.cn">Watcha</a> is an innovative ecosystem and community built for AI builders, connecting great products with high-quality users to turn every Demo into reality. Starting from AI product discovery and genuine feedback, Watcha provides product publishing, distribution, and reputation tracking to support builders from launch to early adoption.</td>
+    <td><a href="https://watcha.cn/r/geIiJJ">Watcha</a> is an innovative ecosystem and community built for AI builders, connecting great products with high-quality users to turn every Demo into reality. Starting from AI product discovery and genuine feedback, Watcha provides product publishing, distribution, and reputation tracking to support builders from launch to early adoption.</td>
   </tr>
   <tr>
     <td width="220" align="center">
@@ -211,9 +215,9 @@ commands and the repository layout.
   </tr>
   <tr>
     <td width="220" align="center">
-      <a href="https://beatapi.io"><img alt="BeatAPI" src="./docs/public/beatapi.png" width="165"></a>
+      <a href="https://beatapi.io/sign-up?aff=hypit"><img alt="BeatAPI" src="./docs/public/beatapi.png" width="165"></a>
     </td>
-    <td><a href="https://beatapi.io">BeatAPI</a> is the professional capability layer for any agent. We provide AI models, real-world data, task-ready capabilities, and professional workspaces that help agents complete real-world tasks.</td>
+    <td><a href="https://beatapi.io/sign-up?aff=hypit">BeatAPI</a> is the professional capability layer for any agent. We provide AI models, real-world data, task-ready capabilities, and professional workspaces that help agents complete real-world tasks.</td>
   </tr>
 </table>
 

package/dist/public/endpoint-kit.d.ts

@@ -383,6 +383,36 @@ declare function wakeAfter(handle: CanonicalValue, delayMs: number, now?: number
     readonly wakeAt: number;
     readonly progress?: OperationProgress;
 };
+/** A service reported a failure with a stable code. */
+declare class EndpointServiceError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/** A non-success HTTP response, with the wait the service asked for when it gave one. */
+declare class EndpointHttpError extends EndpointServiceError {
+    readonly status: number;
+    readonly retryAfterMs?: number | undefined;
+    constructor(code: string, message: string, status: number, retryAfterMs?: number | undefined);
+}
+/** The request produced no response: connection failure, interrupted read, or request timeout. */
+declare class EndpointTransportError extends Error {
+}
+/** A success response whose body cannot be used. */
+declare class EndpointResponseError extends Error {
+}
+/** Report a rejected send or read as a transport error. */
+declare function transport<T>(request: Promise<T>): Promise<T>;
+/** The wait a `Retry-After` header asks for, in milliseconds; either delay-seconds or an HTTP-date. */
+declare function retryAfterMs(headers: Headers, now?: number): number | undefined;
+/**
+ * Decide a poll action's outcome from the error it threw. Transport errors and HTTP 429/5xx keep the
+ * job pending for the next poll; every other error, including credential and response errors, fails it.
+ */
+declare function pollAgainOrFail(error: unknown, options: {
+    readonly handle: CanonicalValue;
+    readonly pollIntervalMs: number;
+    readonly failure: (error: unknown) => EndpointOutcome;
+}): EndpointOutcome;
 
-export { actionResourceClaims, canonicalize, credentialRef, defineEndpointPackage, endpointActions, endpointResourceClaims, isStreamingResourceStore, verifyEndpointPricingDocument, wakeAfter };
+export { EndpointHttpError, EndpointResponseError, EndpointServiceError, EndpointTransportError, actionResourceClaims, canonicalize, credentialRef, defineEndpointPackage, endpointActions, endpointResourceClaims, isStreamingResourceStore, pollAgainOrFail, retryAfterMs, transport, verifyEndpointPricingDocument, wakeAfter };
 export type { AsyncEndpoint, AsyncEndpointCapability, Awaitable, BlobRef, CanonicalValue, CapabilityRef, CapacityResourceClaim, CredentialAcquisition, CredentialRef, CredentialValue, DefineEndpointPackageOptions, EndpointAction, EndpointActionLimits, EndpointCancelOutcome, EndpointCapability, EndpointCheckpoint, EndpointCredential, EndpointCredentialDescription, EndpointFulfillment, EndpointInputSlot, EndpointInvocationContext, EndpointOffer, EndpointOutcome, EndpointPackage, EndpointPollContext, EndpointPricing, EndpointPricingDocument, EndpointPricingReader, EndpointPricingReaderContext, EndpointRegistrar, EndpointRegistrationOptions, EndpointRequest, EndpointScheduling, EndpointStartContext, EndpointSupport, ImmediateEndpointCapability, ImmediateEndpointHandler, ModuleRef, OperationFailure, OperationProgress, OperationReceipt, ResourceIOOptions, ResourceId, ResourceStore, StoredValue, TypeRef };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypit/hypit",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "homepage": "https://hypit.ai",
   "repository": {
     "type": "git",

package/packages/endpoint-kit/src/index.ts

@@ -492,3 +492,50 @@ export function wakeAfter(
     ...(progress === undefined ? {} : { progress }),
   };
 }
+
+/** A service reported a failure with a stable code. */
+export class EndpointServiceError extends Error {
+  constructor(readonly code: string, message: string) { super(message); }
+}
+/** A non-success HTTP response, with the wait the service asked for when it gave one. */
+export class EndpointHttpError extends EndpointServiceError {
+  constructor(code: string, message: string, readonly status: number, readonly retryAfterMs?: number) { super(code, message); }
+}
+/** The request produced no response: connection failure, interrupted read, or request timeout. */
+export class EndpointTransportError extends Error {}
+/** A success response whose body cannot be used. */
+export class EndpointResponseError extends Error {}
+
+/** Report a rejected send or read as a transport error. */
+export async function transport<T>(request: Promise<T>): Promise<T> {
+  try { return await request; } catch (error) {
+    if (error instanceof EndpointTransportError) throw error;
+    throw new EndpointTransportError(error instanceof Error ? error.message : String(error), { cause: error });
+  }
+}
+
+/** The wait a `Retry-After` header asks for, in milliseconds; either delay-seconds or an HTTP-date. */
+export function retryAfterMs(headers: Headers, now = Date.now()): number | undefined {
+  const value = headers.get("retry-after")?.trim();
+  if (value === undefined || value.length === 0) return undefined;
+  const delay = /^\d+$/u.test(value) ? Number(value) * 1000 : Date.parse(value) - now;
+  return Number.isFinite(delay) ? Math.max(0, Math.round(delay)) : undefined;
+}
+
+/**
+ * Decide a poll action's outcome from the error it threw. Transport errors and HTTP 429/5xx keep the
+ * job pending for the next poll; every other error, including credential and response errors, fails it.
+ */
+export function pollAgainOrFail(error: unknown, options: {
+  readonly handle: CanonicalValue;
+  readonly pollIntervalMs: number;
+  readonly failure: (error: unknown) => EndpointOutcome;
+}): EndpointOutcome {
+  if (error instanceof EndpointTransportError) {
+    return wakeAfter(options.handle, options.pollIntervalMs, Date.now(), { phase: "retrying" });
+  }
+  if (error instanceof EndpointHttpError && (error.status === 429 || error.status >= 500)) {
+    return wakeAfter(options.handle, error.retryAfterMs ?? options.pollIntervalMs, Date.now(), { phase: "retrying" });
+  }
+  return options.failure(error);
+}

package/packages/pixverse/README.md

@@ -4,7 +4,7 @@ Exact author/compute contracts and package-owned author Surfaces for PixVerse. T
 two exact models, `pixverse-v6` and `pixverse-c1`, and selects no Provider, API key or network
 execution. The selected Provider implements the exact capability.
 
-Both models render 1 to 15 seconds at `360p`, `540p`, `720p` or `1080p` from a prompt of up to
+Both models render 1 to 15 seconds at `540p` or `720p` from a prompt of up to
 5,000 characters. `<pix:Video>` generates from the prompt, from a first frame, or from a first and
 last frame; `<pix:ReferenceVideo>` generates from the image and video subjects its `Reference`
 children carry.

package/packages/pixverse/src/index.ts

@@ -17,7 +17,7 @@ export const pixverseModuleRef = { name: "@hypit/pixverse", version: "1" } as co
 export const pixverseModels = ["pixverse-v6", "pixverse-c1"] as const;
 export type PixverseModel = typeof pixverseModels[number];
 
-const PIXVERSE_QUALITIES = ["360p", "540p", "720p", "1080p"] as const;
+const PIXVERSE_QUALITIES = ["540p", "720p"] as const;
 const PIXVERSE_ASPECT_RATIOS = ["16:9", "4:3", "1:1", "3:4", "9:16", "2:3", "3:2", "21:9"] as const;
 /** V6 reads `auto` as the shape of the reference videos it generates from. */
 const PIXVERSE_V6_ASPECT_RATIOS = [...PIXVERSE_ASPECT_RATIOS, "auto"] as const;
@@ -142,7 +142,7 @@ const pixverseVideoPort: readonly SurfacePortVocabulary[] = [{
   summary: "The generated video, addressed as `<id>.video`.",
 }];
 
-const pixverseQualityNote = "`quality` is `360p`, `540p`, `720p` or `1080p`, and `duration` is 1 to 15 seconds.";
+const pixverseQualityNote = "`quality` is `540p` or `720p`, and `duration` is 1 to 15 seconds.";
 const pixversePromptNote = "A spoken line belongs in the prompt; the model exposes no separate voice, language or dialogue field.";
 const pixverseModelNote = "V6 accepts `seed` and up to ten references; C1 accepts up to seven references.";
 

package/packages/provider-beatapi/src/errors.ts

@@ -1,3 +1,5 @@
+import { EndpointHttpError, EndpointServiceError } from "@hypit/endpoint-kit";
+
 /** BeatAPI's `{ error: { code, message, request_id, retry_after_seconds } }` envelope and terminal task errors. */
 function record(value: unknown): Record<string, unknown> | undefined {
   return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -12,12 +14,10 @@ export function safeBeatApiReason(value: string): string {
   return value.replace(/https?:\/\/\S+/giu, "[redacted-url]");
 }
 
-export class BeatApiServiceError extends Error {
-  constructor(readonly code: string, message: string) { super(message); }
-}
+export class BeatApiServiceError extends EndpointServiceError {}
 
-export class BeatApiHttpError extends BeatApiServiceError {
-  constructor(readonly status: number, response: { readonly headers: Headers }, bodyText: string,
+export class BeatApiHttpError extends EndpointHttpError {
+  constructor(status: number, response: { readonly headers: Headers }, bodyText: string,
     request: { readonly method: string; readonly path: string; readonly model?: string }) {
     let body: Record<string, unknown> | undefined;
     try { body = record(JSON.parse(bodyText)); } catch { /* Non-JSON gateway failures still have HTTP evidence. */ }
@@ -32,7 +32,8 @@ export class BeatApiHttpError extends BeatApiServiceError {
       ...(requestId === undefined ? [] : [`request=${requestId}`]),
       ...(retryAfter === undefined ? [] : [`retry-after=${retryAfter}s`]),
     ];
-    super(code, `${facts.join("; ")}${reason === undefined ? "" : `: ${safeBeatApiReason(reason)}`}`);
+    super(code, `${facts.join("; ")}${reason === undefined ? "" : `: ${safeBeatApiReason(reason)}`}`,
+      status, retryAfter === undefined ? undefined : Math.round(retryAfter * 1000));
   }
 }
 

package/packages/provider-beatapi/src/provider.ts

@@ -1,6 +1,6 @@
 import { requestDeadline } from "@hypit/runtime-kit";
 import type { AsyncEndpoint, EndpointCredential, EndpointInvocationContext, EndpointOutcome } from "@hypit/endpoint-kit";
-import { defineEndpointPackage, wakeAfter } from "@hypit/endpoint-kit";
+import { EndpointResponseError, EndpointServiceError, EndpointTransportError, defineEndpointPackage, pollAgainOrFail, transport, wakeAfter } from "@hypit/endpoint-kit";
 import type { GenerationArtifactUrlResolver } from "@hypit/generation";
 import { canonicalize } from "@hypit/protocol";
 import type { BlobRef, CapabilityRef } from "@hypit/protocol";
@@ -75,18 +75,18 @@ function failureMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 function failure(error: unknown): EndpointOutcome {
-  return { status: "failed", failure: { code: error instanceof BeatApiServiceError ? error.code : "BEATAPI_ERROR", message: failureMessage(error) } };
+  return { status: "failed", failure: { code: error instanceof EndpointServiceError ? error.code : "BEATAPI_ERROR", message: failureMessage(error) } };
 }
 
 class BeatApiClient {
   constructor(readonly baseUrl: string, readonly timeout: number, readonly fetcher: typeof globalThis.fetch) {}
   async json(path: string, key: string, init: RequestInit = {}): Promise<Record<string, unknown>> {
-    const deadline = requestDeadline(this.timeout);
+    const deadline = requestDeadline(this.timeout, () => new EndpointTransportError("BeatAPI request timed out"));
     try {
-      const response = await deadline.wait(this.fetcher(`${this.baseUrl}${path}`, {
+      const response = await transport(deadline.wait(this.fetcher(`${this.baseUrl}${path}`, {
         ...init, signal: deadline.signal, headers: { authorization: `Bearer ${key}`, ...(init.headers ?? {}) },
-      }));
-      const text = await deadline.wait(response.text());
+      })));
+      const text = await transport(deadline.wait(response.text()));
       if (!response.ok) {
         const input = typeof init.body === "string" ? JSON.parse(init.body) as Record<string, unknown> : undefined;
         throw new BeatApiHttpError(response.status, response, text, {
@@ -94,7 +94,7 @@ class BeatApiClient {
         });
       }
       let body: unknown;
-      try { body = text.length === 0 ? {} : JSON.parse(text); } catch { throw new Error(`BeatAPI returned invalid JSON (${response.status})`); }
+      try { body = text.length === 0 ? {} : JSON.parse(text); } catch { throw new EndpointResponseError(`BeatAPI returned invalid JSON (${response.status})`); }
       return object(object(body, "BeatAPI response").data, "BeatAPI response data");
     } finally { deadline.finish(); }
   }
@@ -154,7 +154,7 @@ function endpoint(client: BeatApiClient, pollIntervalMs: number, maxOperationMs:
         try {
           body = await request.compile(resolverFor(client, context, publicAssetUrl));
         } catch (error) {
-          throw new BeatApiServiceError(error instanceof BeatApiServiceError ? error.code : "BEATAPI_ERROR",
+          throw new BeatApiServiceError(error instanceof EndpointServiceError ? error.code : "BEATAPI_ERROR",
             `BeatAPI request preparation failed; model=${request.model}; generation not submitted: ${failureMessage(error)}`);
         }
         await context.reportProgress?.({ phase: `Submitting BeatAPI request: ${request.model}` });
@@ -194,7 +194,7 @@ function endpoint(client: BeatApiClient, pollIntervalMs: number, maxOperationMs:
         const urls = media.map((item, index) => httpsUrl(object(item, `BeatAPI output ${index + 1}`).url, `BeatAPI output ${index + 1}`));
         return { status: "ready", handle: canonicalize({ ...handle, urls }), receipt };
       } catch (error) {
-        return failure(error);
+        return pollAgainOrFail(error, { handle: context.handle, pollIntervalMs, failure });
       }
     },
     async collect(context) {

package/packages/provider-hiapi/src/errors.ts

@@ -1,3 +1,5 @@
+import { EndpointHttpError, EndpointServiceError } from "@hypit/endpoint-kit";
+
 /** HiAPI's `{ code, message, error_code }` envelope and task `error` object, kept at the service boundary. */
 function record(value: unknown): Record<string, unknown> | undefined {
   return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -12,12 +14,10 @@ export function safeHiApiReason(value: string): string {
   return value.replace(/https?:\/\/\S+/giu, "[redacted-url]");
 }
 
-export class HiApiServiceError extends Error {
-  constructor(readonly code: string, message: string) { super(message); }
-}
+export class HiApiServiceError extends EndpointServiceError {}
 
-export class HiApiHttpError extends HiApiServiceError {
-  constructor(readonly status: number, response: { readonly headers: Headers }, bodyText: string,
+export class HiApiHttpError extends EndpointHttpError {
+  constructor(status: number, response: { readonly headers: Headers }, bodyText: string,
     request: { readonly method: string; readonly path: string; readonly model?: string }) {
     let body: Record<string, unknown> | undefined;
     try { body = record(JSON.parse(bodyText)); } catch { /* Non-JSON gateway failures still have HTTP evidence. */ }
@@ -29,7 +29,7 @@ export class HiApiHttpError extends HiApiServiceError {
       ...(request.model === undefined ? [] : [`model=${request.model}`]),
       ...(requestId === undefined ? [] : [`request=${requestId}`]),
     ];
-    super(code, `${facts.join("; ")}${reason === undefined ? "" : `: ${safeHiApiReason(reason)}`}`);
+    super(code, `${facts.join("; ")}${reason === undefined ? "" : `: ${safeHiApiReason(reason)}`}`, status);
   }
 }
 

package/packages/provider-hiapi/src/provider.ts

@@ -1,6 +1,6 @@
 import { requestDeadline } from "@hypit/runtime-kit";
 import type { AsyncEndpoint, EndpointCredential, EndpointInvocationContext, EndpointOutcome } from "@hypit/endpoint-kit";
-import { defineEndpointPackage, wakeAfter } from "@hypit/endpoint-kit";
+import { EndpointResponseError, EndpointServiceError, EndpointTransportError, defineEndpointPackage, pollAgainOrFail, transport, wakeAfter } from "@hypit/endpoint-kit";
 import type { GenerationArtifactUrlResolver } from "@hypit/generation";
 import { canonicalize } from "@hypit/protocol";
 import type { BlobRef, CapabilityRef } from "@hypit/protocol";
@@ -56,18 +56,18 @@ function failureMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 function failure(error: unknown): EndpointOutcome {
-  return { status: "failed", failure: { code: error instanceof HiApiServiceError ? error.code : "HIAPI_ERROR", message: failureMessage(error) } };
+  return { status: "failed", failure: { code: error instanceof EndpointServiceError ? error.code : "HIAPI_ERROR", message: failureMessage(error) } };
 }
 
 class HiApiClient {
   constructor(readonly baseUrl: string, readonly timeout: number, readonly fetcher: typeof globalThis.fetch) {}
   async json(path: string, key: string, init: RequestInit = {}): Promise<Record<string, unknown>> {
-    const deadline = requestDeadline(this.timeout);
+    const deadline = requestDeadline(this.timeout, () => new EndpointTransportError("HiAPI request timed out"));
     try {
-      const response = await deadline.wait(this.fetcher(`${this.baseUrl}${path}`, {
+      const response = await transport(deadline.wait(this.fetcher(`${this.baseUrl}${path}`, {
         ...init, signal: deadline.signal, headers: { authorization: `Bearer ${key}`, ...(init.headers ?? {}) },
-      }));
-      const text = await deadline.wait(response.text());
+      })));
+      const text = await transport(deadline.wait(response.text()));
       if (!response.ok) {
         const input = typeof init.body === "string" ? JSON.parse(init.body) as Record<string, unknown> : undefined;
         throw new HiApiHttpError(response.status, response, text, {
@@ -75,7 +75,7 @@ class HiApiClient {
         });
       }
       let body: unknown;
-      try { body = text.length === 0 ? {} : JSON.parse(text); } catch { throw new Error(`HiAPI returned invalid JSON (${response.status})`); }
+      try { body = text.length === 0 ? {} : JSON.parse(text); } catch { throw new EndpointResponseError(`HiAPI returned invalid JSON (${response.status})`); }
       return object(object(body, "HiAPI response").data, "HiAPI response data");
     } finally { deadline.finish(); }
   }
@@ -130,7 +130,7 @@ function endpoint(client: HiApiClient, pollIntervalMs: number, maxOperationMs: n
         try {
           body = await request.compile(resolverFor(request.mediaLimits, context, publicAssetUrl));
         } catch (error) {
-          throw new HiApiServiceError(error instanceof HiApiServiceError ? error.code : "HIAPI_ERROR",
+          throw new HiApiServiceError(error instanceof EndpointServiceError ? error.code : "HIAPI_ERROR",
             `HiAPI request preparation failed; model=${request.model}; generation not submitted: ${failureMessage(error)}`);
         }
         await context.reportProgress?.({ phase: `Submitting HiAPI request: ${request.model}` });
@@ -171,7 +171,7 @@ function endpoint(client: HiApiClient, pollIntervalMs: number, maxOperationMs: n
         });
         return { status: "ready", handle: canonicalize({ ...handle, urls }), receipt };
       } catch (error) {
-        return failure(error);
+        return pollAgainOrFail(error, { handle: context.handle, pollIntervalMs, failure });
       }
     },
     async collect(context) {

package/packages/provider-hypihub/src/errors.ts

@@ -1,3 +1,5 @@
+import { EndpointHttpError, EndpointServiceError, retryAfterMs } from "@hypit/endpoint-kit";
+
 /** HypiHub's public error envelope, kept at the service boundary. */
 function record(value: unknown): Record<string, unknown> | undefined {
   return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -12,13 +14,10 @@ export function safeHypiHubReason(value: string): string {
   return value.replace(/https?:\/\/\S+/giu, "[redacted-url]");
 }
 
-export class HypiHubServiceError extends Error {
-  constructor(readonly code: string, message: string) { super(message); }
-}
+export class HypiHubServiceError extends EndpointServiceError {}
 
-export class HypiHubHttpError extends HypiHubServiceError {
-  readonly retryAfterMs?: number;
-  constructor(readonly status: number, response: { readonly headers: Headers }, bodyText: string,
+export class HypiHubHttpError extends EndpointHttpError {
+  constructor(status: number, response: { readonly headers: Headers }, bodyText: string,
     request: { readonly method: string; readonly url: string; readonly model?: string }) {
     let body: Record<string, unknown> | undefined;
     try { body = record(JSON.parse(bodyText)); } catch { /* Non-JSON gateway failures still have HTTP evidence. */ }
@@ -41,10 +40,8 @@ export class HypiHubHttpError extends HypiHubServiceError {
       ...(retryAfter === undefined ? [] : [`retry-after=${retryAfter}`]),
     ];
     super(code, `${facts.join("; ")}${reason === undefined ? "" : `: ${safeHypiHubReason(reason)}`}`
-      + (body === undefined && bodyText.length > 2000 ? " [response excerpt truncated]" : ""));
-    const delay = retryAfter === undefined ? NaN : /^\d+$/u.test(retryAfter)
-      ? Number(retryAfter) * 1000 : Date.parse(retryAfter) - Date.now();
-    if (Number.isFinite(delay)) this.retryAfterMs = Math.max(0, delay);
+      + (body === undefined && bodyText.length > 2000 ? " [response excerpt truncated]" : ""),
+    status, retryAfterMs(response.headers));
   }
 }
 

package/packages/provider-hypihub/src/oauth.ts

@@ -1,4 +1,5 @@
 import type { EndpointCredential } from "@hypit/endpoint-kit";
+import { EndpointTransportError, transport } from "@hypit/endpoint-kit";
 import { decodeOAuth2Credential, encodeOAuth2Credential } from "@hypit/runtime";
 import { requestDeadline } from "@hypit/runtime-kit";
 import { HypiHubHttpError } from "./errors.js";
@@ -66,9 +67,9 @@ export function createHypiHubAuth(options: {
       throw new Error("HypiHub OAuth credential is read-only; run hypit auth login with a writable Credential Store");
     }
     refreshing = (async () => {
-      const deadline = requestDeadline(options.requestTimeoutMs, () => new Error("HypiHub OAuth refresh timed out"));
+      const deadline = requestDeadline(options.requestTimeoutMs, () => new EndpointTransportError("HypiHub OAuth refresh timed out"));
       try {
-        const response = await deadline.wait(options.fetch(tokenEndpoint, {
+        const response = await transport(deadline.wait(options.fetch(tokenEndpoint, {
           method: "POST",
           headers: { "content-type": "application/x-www-form-urlencoded" },
           body: new URLSearchParams({
@@ -77,8 +78,8 @@ export function createHypiHubAuth(options: {
             client_id: OAUTH_CLIENT_ID,
           }),
           signal: deadline.signal,
-        }));
-        const text = await deadline.wait(response.text());
+        })));
+        const text = await transport(deadline.wait(response.text()));
         if (!response.ok) throw new HypiHubHttpError(response.status, response, text, {
           method: "POST", url: tokenEndpoint,
         });

package/packages/provider-hypihub/src/provider.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { requestDeadline } from "@hypit/runtime-kit";
 import type { AsyncEndpoint, EndpointCredential, EndpointFulfillment, EndpointInvocationContext, EndpointPollContext, EndpointPricingReader, EndpointStartContext, EndpointOutcome, ImmediateEndpointHandler } from "@hypit/endpoint-kit";
-import { defineEndpointPackage, wakeAfter } from "@hypit/endpoint-kit";
+import { EndpointResponseError, EndpointServiceError, EndpointTransportError, defineEndpointPackage, pollAgainOrFail, transport, wakeAfter } from "@hypit/endpoint-kit";
 import { selectWireModelForRequest } from "@hypit/generation";
 import type { GenerationRequest } from "@hypit/generation";
 import { canonicalize } from "@hypit/protocol";
@@ -98,7 +98,7 @@ function failureMessage(error: unknown): string {
 }
 function failure(error: unknown): EndpointOutcome {
   const message = failureMessage(error);
-  return { status: "failed", failure: { code: error instanceof HypiHubServiceError ? error.code : "HYPIHUB_ERROR", message } };
+  return { status: "failed", failure: { code: error instanceof EndpointServiceError ? error.code : "HYPIHUB_ERROR", message } };
 }
 
 function jobId(value: Record<string, unknown>): string {
@@ -150,11 +150,11 @@ class HypiHubClient {
   async json(path: string, auth: HypiHubAuth, init: RequestInit = {}, refreshOnUnauthorized = true,
     onResponse?: (response: Response) => Promise<void>): Promise<Record<string, unknown>> {
     const token = await auth.token();
-    const deadline = requestDeadline(this.timeout);
+    const deadline = requestDeadline(this.timeout, () => new EndpointTransportError("HypiHub request timed out"));
     try {
-      const response = await deadline.wait(this.fetcher(`${this.baseUrl}${path}`, { ...init, signal: deadline.signal, headers: { authorization: `Bearer ${token}`, ...(init.headers ?? {}) } }));
+      const response = await transport(deadline.wait(this.fetcher(`${this.baseUrl}${path}`, { ...init, signal: deadline.signal, headers: { authorization: `Bearer ${token}`, ...(init.headers ?? {}) } })));
       if (response.status !== 401 && onResponse !== undefined) await deadline.wait(onResponse(response));
-      const text = await deadline.wait(response.text()); let body: unknown = {};
+      const text = await transport(deadline.wait(response.text())); let body: unknown = {};
       if (response.status === 401 && refreshOnUnauthorized && auth.canRefresh()) {
         deadline.finish();
         await auth.refresh();
@@ -167,7 +167,7 @@ class HypiHubClient {
           ...(typeof input?.model === "string" ? { model: input.model } : {}),
         });
       }
-      try { body = text.length === 0 ? {} : JSON.parse(text); } catch { throw new Error(`HypiHub returned invalid JSON (${response.status})`); }
+      try { body = text.length === 0 ? {} : JSON.parse(text); } catch { throw new EndpointResponseError(`HypiHub returned invalid JSON (${response.status})`); }
       return object(body, "HypiHub response");
     } finally { deadline.finish(); }
   }
@@ -427,7 +427,7 @@ async function prepareGeneration(client: HypiHubClient, context: EndpointInvocat
   try {
     await verifyModelRoute(client, auth, request.model, request.operation);
   } catch (error) {
-    throw new HypiHubServiceError(error instanceof HypiHubServiceError ? error.code : "HYPIHUB_ERROR",
+    throw new HypiHubServiceError(error instanceof EndpointServiceError ? error.code : "HYPIHUB_ERROR",
       `HypiHub model catalogue check failed; model=${request.model}; operation=${request.operation}; references uploaded=0; generation not submitted: ${failureMessage(error)}`);
   }
   await context.reportProgress?.({ phase: `Preparing HypiHub request: ${request.model} (${request.operation})` });
@@ -446,7 +446,7 @@ async function prepareGeneration(client: HypiHubClient, context: EndpointInvocat
   try {
     compiled = await request.compile(resolve);
   } catch (error) {
-    throw new HypiHubServiceError(error instanceof HypiHubServiceError ? error.code : "HYPIHUB_ERROR",
+    throw new HypiHubServiceError(error instanceof EndpointServiceError ? error.code : "HYPIHUB_ERROR",
       `HypiHub request preparation failed; model=${request.model}; operation=${request.operation}; generation not submitted: ${failureMessage(error)}`);
   }
   return { route, auth, compiled, operation: request.operation };
@@ -501,7 +501,7 @@ function endpoint(client: HypiHubClient, pollIntervalMs: number, maxOperationMs:
         if (status !== "succeeded" && status !== "completed") throw new Error(`HypiHub returned unknown job status ${String(status)}`);
         return { status: "ready", handle: context.handle, receipt: { id: handle.jobId } };
       } catch (error) {
-        return failure(error);
+        return pollAgainOrFail(error, { handle: context.handle, pollIntervalMs, failure });
       }
     },
     async collect(context) {

package/packages/provider-hypihub/src/upload.ts

@@ -1,8 +1,9 @@
+import { EndpointServiceError } from "@hypit/endpoint-kit";
 import { requestDeadline } from "@hypit/runtime-kit";
 import { createHash } from "node:crypto";
 
 import type { HypiHubAuth } from "./oauth.js";
-import { HypiHubHttpError, HypiHubServiceError, safeHypiHubReason } from "./errors.js";
+import { HypiHubHttpError, safeHypiHubReason } from "./errors.js";
 
 type UploadAuth = HypiHubAuth | string;
 
@@ -360,7 +361,7 @@ export class HypiHubUploader {
           this.log(`upload cancellation still pending upload=${uploadId} reason=${this.safeReason(cancelError)}`);
         }
       }
-      throw error instanceof HypiHubServiceError ? error : new Error(this.safeReason(error));
+      throw error instanceof EndpointServiceError ? error : new Error(this.safeReason(error));
     }
   }
 

package/packages/provider-monid/src/errors.ts

@@ -1,3 +1,5 @@
+import { EndpointHttpError, EndpointServiceError } from "@hypit/endpoint-kit";
+
 /** Monid's `{ code, message }` error envelope and run outcome fields, kept at the service boundary. */
 function record(value: unknown): Record<string, unknown> | undefined {
   return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -12,12 +14,10 @@ export function safeMonidReason(value: string): string {
   return value.replace(/https?:\/\/\S+/giu, "[redacted-url]");
 }
 
-export class MonidServiceError extends Error {
-  constructor(readonly code: string, message: string) { super(message); }
-}
+export class MonidServiceError extends EndpointServiceError {}
 
-export class MonidHttpError extends MonidServiceError {
-  constructor(readonly status: number, response: { readonly headers: Headers }, bodyText: string,
+export class MonidHttpError extends EndpointHttpError {
+  constructor(status: number, response: { readonly headers: Headers }, bodyText: string,
     request: { readonly method: string; readonly path: string }) {
     let body: Record<string, unknown> | undefined;
     try { body = record(JSON.parse(bodyText)); } catch { /* Non-JSON gateway failures still have HTTP evidence. */ }
@@ -27,7 +27,7 @@ export class MonidHttpError extends MonidServiceError {
       `Monid HTTP ${status}`, `${request.method} ${request.path}`,
       ...(requestId === undefined ? [] : [`request=${requestId}`]),
     ];
-    super("MONID_HTTP_ERROR", `${facts.join("; ")}${reason === undefined ? "" : `: ${safeMonidReason(reason)}`}`);
+    super("MONID_HTTP_ERROR", `${facts.join("; ")}${reason === undefined ? "" : `: ${safeMonidReason(reason)}`}`, status);
   }
 }
 

package/packages/provider-monid/src/provider.ts

@@ -1,6 +1,6 @@
 import { requestDeadline } from "@hypit/runtime-kit";
 import type { AsyncEndpoint, EndpointCredential, EndpointInvocationContext, EndpointOutcome } from "@hypit/endpoint-kit";
-import { defineEndpointPackage, wakeAfter } from "@hypit/endpoint-kit";
+import { EndpointResponseError, EndpointServiceError, EndpointTransportError, defineEndpointPackage, pollAgainOrFail, transport, wakeAfter } from "@hypit/endpoint-kit";
 import type { GenerationArtifactUrlResolver } from "@hypit/generation";
 import { canonicalize } from "@hypit/protocol";
 import type { BlobRef, CapabilityRef } from "@hypit/protocol";
@@ -55,7 +55,7 @@ function failureMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 function failure(error: unknown): EndpointOutcome {
-  return { status: "failed", failure: { code: error instanceof MonidServiceError ? error.code : "MONID_ERROR", message: failureMessage(error) } };
+  return { status: "failed", failure: { code: error instanceof EndpointServiceError ? error.code : "MONID_ERROR", message: failureMessage(error) } };
 }
 function runId(run: Record<string, unknown>): string {
   assert(typeof run.runId === "string" && run.runId.length > 0, "Monid response has no runId");
@@ -90,18 +90,18 @@ const extensions: Readonly<Record<string, string>> = {
 class MonidClient {
   constructor(readonly baseUrl: string, readonly timeout: number, readonly pollIntervalMs: number, readonly fetcher: typeof globalThis.fetch) {}
   async json(path: string, key: string, init: RequestInit = {}): Promise<{ readonly status: number; readonly body: Record<string, unknown> }> {
-    const deadline = requestDeadline(this.timeout);
+    const deadline = requestDeadline(this.timeout, () => new EndpointTransportError("Monid request timed out"));
     try {
-      const response = await deadline.wait(this.fetcher(`${this.baseUrl}${path}`, {
+      const response = await transport(deadline.wait(this.fetcher(`${this.baseUrl}${path}`, {
         ...init, signal: deadline.signal, headers: { authorization: `Bearer ${key}`, ...(init.headers ?? {}) },
-      }));
-      const text = await deadline.wait(response.text());
+      })));
+      const text = await transport(deadline.wait(response.text()));
       let body: unknown;
       try { body = text.length === 0 ? {} : JSON.parse(text); } catch { body = undefined; }
       // A synchronous run mirrors the provider's HTTP status while still returning the run itself.
       const run = body !== null && typeof body === "object" && !Array.isArray(body) && typeof (body as Record<string, unknown>).runId === "string";
       if (!response.ok && !run) throw new MonidHttpError(response.status, response, text, { method: init.method ?? "GET", path });
-      assert(body !== undefined, `Monid returned invalid JSON (${response.status})`);
+      if (body === undefined) throw new EndpointResponseError(`Monid returned invalid JSON (${response.status})`);
       return { status: response.status, body: object(body, "Monid response") };
     } finally { deadline.finish(); }
   }
@@ -176,7 +176,7 @@ function endpoint(client: MonidClient, pollIntervalMs: number, maxOperationMs: n
         try {
           input = await request.compile(resolverFor(client, context, publicAssetUrl));
         } catch (error) {
-          throw new MonidServiceError(error instanceof MonidServiceError ? error.code : "MONID_ERROR",
+          throw new MonidServiceError(error instanceof EndpointServiceError ? error.code : "MONID_ERROR",
             `Monid request preparation failed; endpoint=${request.endpoint}; generation not submitted: ${failureMessage(error)}`);
         }
         await context.reportProgress?.({ phase: `Submitting Monid request: ${request.service} ${request.endpoint}` });
@@ -211,7 +211,7 @@ function endpoint(client: MonidClient, pollIntervalMs: number, maxOperationMs: n
         if (rejected !== undefined) return { ...failure(rejected), receipt };
         return { status: "ready", handle: canonicalize({ ...handle, urls: outputUrls(run) }), receipt };
       } catch (error) {
-        return failure(error);
+        return pollAgainOrFail(error, { handle: context.handle, pollIntervalMs, failure });
       }
     },
     async collect(context) {

package/packages/provider-pollo/src/errors.ts

@@ -1,3 +1,5 @@
+import { EndpointHttpError, EndpointServiceError } from "@hypit/endpoint-kit";
+
 /** Pollo's `{ errorCode, message, code, requestId }` envelope and generation `failMsg`, kept at the service boundary. */
 function record(value: unknown): Record<string, unknown> | undefined {
   return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -12,12 +14,10 @@ export function safePolloReason(value: string): string {
   return value.replace(/https?:\/\/\S+/giu, "[redacted-url]");
 }
 
-export class PolloServiceError extends Error {
-  constructor(readonly code: string, message: string) { super(message); }
-}
+export class PolloServiceError extends EndpointServiceError {}
 
-export class PolloHttpError extends PolloServiceError {
-  constructor(readonly status: number, bodyText: string, request: { readonly method: string; readonly path: string }) {
+export class PolloHttpError extends EndpointHttpError {
+  constructor(status: number, bodyText: string, request: { readonly method: string; readonly path: string }) {
     let body: Record<string, unknown> | undefined;
     try { body = record(JSON.parse(bodyText)); } catch { /* Non-JSON gateway failures still have HTTP evidence. */ }
     const code = text(body?.errorCode) ?? "POLLO_HTTP_ERROR";
@@ -27,7 +27,7 @@ export class PolloHttpError extends PolloServiceError {
       `Pollo HTTP ${status}`, code, `${request.method} ${request.path}`,
       ...(requestId === undefined ? [] : [`request=${requestId}`]),
     ];
-    super(code, `${facts.join("; ")}${reason === undefined ? "" : `: ${safePolloReason(reason)}`}`);
+    super(code, `${facts.join("; ")}${reason === undefined ? "" : `: ${safePolloReason(reason)}`}`, status);
   }
 }
 

package/packages/provider-pollo/src/provider.ts

@@ -1,6 +1,6 @@
 import { requestDeadline } from "@hypit/runtime-kit";
 import type { AsyncEndpoint, EndpointCredential, EndpointInvocationContext, EndpointOutcome } from "@hypit/endpoint-kit";
-import { defineEndpointPackage, wakeAfter } from "@hypit/endpoint-kit";
+import { EndpointResponseError, EndpointServiceError, EndpointTransportError, defineEndpointPackage, pollAgainOrFail, transport, wakeAfter } from "@hypit/endpoint-kit";
 import type { GenerationArtifactUrlResolver } from "@hypit/generation";
 import { canonicalize } from "@hypit/protocol";
 import type { BlobRef, CapabilityRef } from "@hypit/protocol";
@@ -55,21 +55,21 @@ function failureMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 function failure(error: unknown): EndpointOutcome {
-  return { status: "failed", failure: { code: error instanceof PolloServiceError ? error.code : "POLLO_ERROR", message: failureMessage(error) } };
+  return { status: "failed", failure: { code: error instanceof EndpointServiceError ? error.code : "POLLO_ERROR", message: failureMessage(error) } };
 }
 
 class PolloClient {
   constructor(readonly baseUrl: string, readonly timeout: number, readonly fetcher: typeof globalThis.fetch) {}
   async json(path: string, key: string, init: RequestInit = {}): Promise<Record<string, unknown>> {
-    const deadline = requestDeadline(this.timeout);
+    const deadline = requestDeadline(this.timeout, () => new EndpointTransportError("Pollo request timed out"));
     try {
-      const response = await deadline.wait(this.fetcher(`${this.baseUrl}${path}`, {
+      const response = await transport(deadline.wait(this.fetcher(`${this.baseUrl}${path}`, {
         ...init, signal: deadline.signal, headers: { "x-api-key": key, ...(init.headers ?? {}) },
-      }));
-      const text = await deadline.wait(response.text());
+      })));
+      const text = await transport(deadline.wait(response.text()));
       if (!response.ok) throw new PolloHttpError(response.status, text, { method: init.method ?? "GET", path });
       let body: unknown;
-      try { body = text.length === 0 ? {} : JSON.parse(text); } catch { throw new Error(`Pollo returned invalid JSON (${response.status})`); }
+      try { body = text.length === 0 ? {} : JSON.parse(text); } catch { throw new EndpointResponseError(`Pollo returned invalid JSON (${response.status})`); }
       return object(body, "Pollo response");
     } finally { deadline.finish(); }
   }
@@ -108,7 +108,7 @@ function endpoint(client: PolloClient, pollIntervalMs: number, maxOperationMs: n
         try {
           body = await request.compile(resolverFor(context, publicAssetUrl));
         } catch (error) {
-          throw new PolloServiceError(error instanceof PolloServiceError ? error.code : "POLLO_ERROR",
+          throw new PolloServiceError(error instanceof EndpointServiceError ? error.code : "POLLO_ERROR",
             `Pollo request preparation failed; path=${request.path}; generation not submitted: ${failureMessage(error)}`);
         }
         await context.reportProgress?.({ phase: `Submitting Pollo request: ${request.path}` });
@@ -150,7 +150,7 @@ function endpoint(client: PolloClient, pollIntervalMs: number, maxOperationMs: n
         });
         return { status: "ready", handle: canonicalize({ ...handle, urls }), receipt };
       } catch (error) {
-        return failure(error);
+        return pollAgainOrFail(error, { handle: context.handle, pollIntervalMs, failure });
       }
     },
     async collect(context) {

package/packages/provider-tokendance/src/errors.ts

@@ -1,3 +1,5 @@
+import { EndpointHttpError, EndpointServiceError } from "@hypit/endpoint-kit";
+
 /** TokenDance relays each protocol's own error body; keep the code, the message and the HTTP facts. */
 function record(value: unknown): Record<string, unknown> | undefined {
   return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -12,12 +14,10 @@ export function safeTokenDanceReason(value: string): string {
   return value.replace(/https?:\/\/\S+/giu, "[redacted-url]");
 }
 
-export class TokenDanceServiceError extends Error {
-  constructor(readonly code: string, message: string) { super(message); }
-}
+export class TokenDanceServiceError extends EndpointServiceError {}
 
-export class TokenDanceHttpError extends TokenDanceServiceError {
-  constructor(readonly status: number, response: { readonly headers: Headers }, bodyText: string,
+export class TokenDanceHttpError extends EndpointHttpError {
+  constructor(status: number, response: { readonly headers: Headers }, bodyText: string,
     request: { readonly method: string; readonly path: string; readonly model?: string }) {
     let body: Record<string, unknown> | undefined;
     try { body = record(JSON.parse(bodyText)); } catch { /* Non-JSON gateway failures still have HTTP evidence. */ }
@@ -31,7 +31,7 @@ export class TokenDanceHttpError extends TokenDanceServiceError {
       ...(request.model === undefined ? [] : [`model=${request.model}`]),
       ...(requestId === undefined ? [] : [`request=${requestId}`]),
     ];
-    super(code, `${facts.join("; ")}${reason === undefined ? "" : `: ${safeTokenDanceReason(reason)}`}`);
+    super(code, `${facts.join("; ")}${reason === undefined ? "" : `: ${safeTokenDanceReason(reason)}`}`, status);
   }
 }
 

package/packages/provider-tokendance/src/provider.ts

@@ -1,6 +1,6 @@
 import { requestDeadline } from "@hypit/runtime-kit";
 import type { AsyncEndpoint, EndpointCredential, EndpointInvocationContext, EndpointOutcome, ImmediateEndpointHandler } from "@hypit/endpoint-kit";
-import { defineEndpointPackage, wakeAfter } from "@hypit/endpoint-kit";
+import { EndpointResponseError, EndpointServiceError, EndpointTransportError, defineEndpointPackage, pollAgainOrFail, transport, wakeAfter } from "@hypit/endpoint-kit";
 import type { GenerationArtifactUrlResolver } from "@hypit/generation";
 import { canonicalize } from "@hypit/protocol";
 import type { BlobRef, CapabilityRef } from "@hypit/protocol";
@@ -56,7 +56,7 @@ function failureMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 function failure(error: unknown): EndpointOutcome {
-  return { status: "failed", failure: { code: error instanceof TokenDanceServiceError ? error.code : "TOKENDANCE_ERROR", message: failureMessage(error) } };
+  return { status: "failed", failure: { code: error instanceof EndpointServiceError ? error.code : "TOKENDANCE_ERROR", message: failureMessage(error) } };
 }
 function httpsUrl(value: unknown, subject: string): string {
   assert(typeof value === "string" && /^https?:\/\//u.test(value), `${subject} has no download URL`);
@@ -66,12 +66,12 @@ function httpsUrl(value: unknown, subject: string): string {
 class TokenDanceClient {
   constructor(readonly baseUrl: string, readonly timeout: number, readonly fetcher: typeof globalThis.fetch) {}
   async json(path: string, key: string, init: RequestInit = {}): Promise<Record<string, unknown>> {
-    const deadline = requestDeadline(this.timeout);
+    const deadline = requestDeadline(this.timeout, () => new EndpointTransportError("TokenDance request timed out"));
     try {
-      const response = await deadline.wait(this.fetcher(`${this.baseUrl}${path}`, {
+      const response = await transport(deadline.wait(this.fetcher(`${this.baseUrl}${path}`, {
         ...init, signal: deadline.signal, headers: { authorization: `Bearer ${key}`, ...(init.headers ?? {}) },
-      }));
-      const text = await deadline.wait(response.text());
+      })));
+      const text = await transport(deadline.wait(response.text()));
       if (!response.ok) {
         const input = typeof init.body === "string" ? JSON.parse(init.body) as Record<string, unknown> : undefined;
         throw new TokenDanceHttpError(response.status, response, text, {
@@ -79,7 +79,7 @@ class TokenDanceClient {
         });
       }
       let body: unknown;
-      try { body = text.length === 0 ? {} : JSON.parse(text); } catch { throw new Error(`TokenDance returned invalid JSON (${response.status})`); }
+      try { body = text.length === 0 ? {} : JSON.parse(text); } catch { throw new EndpointResponseError(`TokenDance returned invalid JSON (${response.status})`); }
       return object(body, "TokenDance response");
     } finally { deadline.finish(); }
   }
@@ -145,7 +145,7 @@ async function prepare(client: TokenDanceClient, context: EndpointInvocationCont
     assert(cap === undefined || Buffer.byteLength(body) <= cap,
       `TokenDance ${route.protocol} accepts request bodies up to ${(cap ?? 0) / 1_000_000} MB; inline references make this one ${Buffer.byteLength(body)} bytes`);
   } catch (error) {
-    throw new TokenDanceServiceError(error instanceof TokenDanceServiceError ? error.code : "TOKENDANCE_ERROR",
+    throw new TokenDanceServiceError(error instanceof EndpointServiceError ? error.code : "TOKENDANCE_ERROR",
       `TokenDance request preparation failed; model=${request.model}; generation not submitted: ${failureMessage(error)}`);
   }
   return { route, model: request.model, body };
@@ -216,7 +216,7 @@ function endpoint(client: TokenDanceClient, pollIntervalMs: number, maxOperation
         assert(status === "succeeded", `TokenDance returned unknown task status ${status}`);
         return { status: "ready", handle: canonicalize({ ...handle, url: taskVideoUrl(route.protocol, task) }), receipt };
       } catch (error) {
-        return failure(error);
+        return pollAgainOrFail(error, { handle: context.handle, pollIntervalMs, failure });
       }
     },
     async collect(context) {