@acedatacloud/sdk 2026.716.1 → 2026.718.1

package/src/runtime/transport.ts

@@ -68,6 +68,18 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function isAbortError(error: unknown): boolean {
+  return typeof error === 'object' && error !== null && 'name' in error && error.name === 'AbortError';
+}
+
+function timeoutError(error: unknown): TimeoutError {
+  return new TimeoutError({
+    message: `Request timed out${error instanceof Error && error.message ? `: ${error.message}` : ''}`,
+    statusCode: 0,
+    code: 'timeout',
+  });
+}
+
 export interface TransportOptions {
   apiToken?: string;
   baseURL?: string;
@@ -104,7 +116,7 @@ export class Transport {
         code: 'no_token',
       });
     }
-    this.baseURL = (opts.baseURL ?? 'https://api.acedata.cloud').replace(/\/+$/, '');
+    this.baseURL = (opts.baseURL ?? 'https://x402.acedata.cloud').replace(/\/+$/, '');
     this.platformBaseURL = (opts.platformBaseURL ?? 'https://platform.acedata.cloud').replace(/\/+$/, '');
     this.timeout = opts.timeout ?? 300_000;
     this.maxRetries = opts.maxRetries ?? 2;
@@ -144,7 +156,8 @@ export class Transport {
     let lastError: Error | null = null;
     let paymentAttempted = false;
     let extraHeaders: Record<string, string> = {};
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+    let attempt = 0;
+    while (true) {
       const controller = new AbortController();
       const timer = setTimeout(() => controller.abort(), timeoutMs);
       try {
@@ -158,20 +171,29 @@ export class Transport {
 
         if (resp.status === 402 && this.paymentHandler && !paymentAttempted) {
           const text = await resp.text();
-          let body: PaymentRequiredBody;
+          let body: unknown;
           try {
-            body = JSON.parse(text) as PaymentRequiredBody;
+            body = JSON.parse(text);
           } catch {
             throw mapError(402, { error: { code: 'invalid_402', message: text } });
           }
-          if (!body.accepts?.length) {
+          if (
+            !body ||
+            typeof body !== 'object' ||
+            !Array.isArray((body as PaymentRequiredBody).accepts) ||
+            !(body as PaymentRequiredBody).accepts.length ||
+            !(body as PaymentRequiredBody).accepts.every(
+              (requirement) => requirement !== null && typeof requirement === 'object'
+            )
+          ) {
             throw mapError(402, { error: { code: 'invalid_402', message: 'No payment requirements' } });
           }
+          const paymentRequired = body as PaymentRequiredBody;
           const result = await this.paymentHandler({
             url,
             method,
             body: opts.json,
-            accepts: body.accepts,
+            accepts: paymentRequired.accepts,
           });
           extraHeaders = { ...extraHeaders, ...result.headers };
           paymentAttempted = true;
@@ -186,8 +208,9 @@ export class Transport {
           } catch {
             body = { error: { code: 'unknown', message: text } };
           }
-          if (RETRY_STATUS_CODES.has(resp.status) && attempt < this.maxRetries) {
+          if (!paymentAttempted && RETRY_STATUS_CODES.has(resp.status) && attempt < this.maxRetries) {
             await sleep(backoffDelay(attempt) * 1000);
+            attempt += 1;
             continue;
           }
           throw mapError(resp.status, body);
@@ -197,14 +220,19 @@ export class Transport {
       } catch (err) {
         clearTimeout(timer);
         if (err instanceof APIError) throw err;
-        lastError = err as Error;
-        if (attempt < this.maxRetries) {
+        if (isAbortError(err)) {
+          lastError = timeoutError(err);
+        } else {
+          lastError = err as Error;
+        }
+        if (!paymentAttempted && attempt < this.maxRetries) {
           await sleep(backoffDelay(attempt) * 1000);
+          attempt += 1;
           continue;
         }
+        throw lastError;
       }
     }
-    throw lastError ?? new TransportError('Request failed after retries');
   }
 
   async *requestStream(
@@ -214,52 +242,115 @@ export class Transport {
   ): AsyncGenerator<string, void, unknown> {
     const url = `${this.baseURL}${path}`;
     const headers = { ...this.headers, accept: 'text/event-stream' };
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), opts.timeout ?? this.timeout);
-
-    try {
-      const resp = await fetch(url, {
-        method,
-        headers,
-        body: opts.json ? JSON.stringify(opts.json) : undefined,
-        signal: controller.signal,
-      });
+    let paymentAttempted = false;
+    let extraHeaders: Record<string, string> = {};
 
-      if (resp.status >= 400) {
-        const text = await resp.text();
-        let body: Record<string, unknown>;
+    while (true) {
+      const controller = new AbortController();
+      const timeoutMs = opts.timeout ?? this.timeout;
+      const connectionTimer = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        let resp: Response;
         try {
-          body = JSON.parse(text) as Record<string, unknown>;
-        } catch {
-          body = { error: { code: 'unknown', message: text } };
+          resp = await fetch(url, {
+            method,
+            headers: { ...headers, ...extraHeaders },
+            body: opts.json ? JSON.stringify(opts.json) : undefined,
+            signal: controller.signal,
+          });
+        } catch (error) {
+          if (isAbortError(error)) throw timeoutError(error);
+          throw error;
+        } finally {
+          clearTimeout(connectionTimer);
+        }
+
+        if (resp.status === 402 && this.paymentHandler && !paymentAttempted) {
+          const text = await resp.text();
+          let body: unknown;
+          try {
+            body = JSON.parse(text);
+          } catch {
+            throw mapError(402, { error: { code: 'invalid_402', message: text } });
+          }
+          if (
+            !body ||
+            typeof body !== 'object' ||
+            !Array.isArray((body as PaymentRequiredBody).accepts) ||
+            !(body as PaymentRequiredBody).accepts.length ||
+            !(body as PaymentRequiredBody).accepts.every(
+              (requirement) => requirement !== null && typeof requirement === 'object'
+            )
+          ) {
+            throw mapError(402, { error: { code: 'invalid_402', message: 'No payment requirements' } });
+          }
+          const paymentRequired = body as PaymentRequiredBody;
+          const result = await this.paymentHandler({
+            url,
+            method,
+            body: opts.json,
+            accepts: paymentRequired.accepts,
+          });
+          extraHeaders = { ...extraHeaders, ...result.headers };
+          paymentAttempted = true;
+          continue;
+        }
+
+        if (resp.status >= 400) {
+          const text = await resp.text();
+          let body: Record<string, unknown>;
+          try {
+            body = JSON.parse(text) as Record<string, unknown>;
+          } catch {
+            body = { error: { code: 'unknown', message: text } };
+          }
+          throw mapError(resp.status, body);
         }
-        throw mapError(resp.status, body);
-      }
 
-      if (!resp.body) throw new TransportError('No response body for stream');
+        if (!resp.body) throw new TransportError('No response body for stream');
 
-      const reader = resp.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = '';
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
 
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
+        try {
+          while (true) {
+            const idleTimer = setTimeout(() => controller.abort(), timeoutMs);
+            let result: Awaited<ReturnType<typeof reader.read>>;
+            try {
+              result = await reader.read();
+            } catch (error) {
+              if (isAbortError(error)) throw timeoutError(error);
+              throw error;
+            } finally {
+              clearTimeout(idleTimer);
+            }
+            const { done, value } = result;
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
 
-        const lines = buffer.split('\n');
-        buffer = lines.pop() ?? '';
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
 
-        for (const line of lines) {
-          if (line.startsWith('data: ')) {
-            const data = line.slice(6);
-            if (data === '[DONE]') return;
-            yield data;
+            for (const line of lines) {
+              if (line.startsWith('data: ')) {
+                const data = line.slice(6);
+                if (data === '[DONE]') return;
+                yield data;
+              }
+            }
+          }
+        } finally {
+          try {
+            await reader.cancel();
+          } catch {
+            // Preserve the original stream error, especially SDK TimeoutError.
           }
         }
+        return;
+      } finally {
+        clearTimeout(connectionTimer);
       }
-    } finally {
-      clearTimeout(timer);
     }
   }
 
@@ -288,12 +379,18 @@ export class Transport {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), opts.timeout ?? this.timeout);
     try {
-      const resp = await fetch(url, {
-        method: 'POST',
-        headers: authHeaders,
-        body,
-        signal: controller.signal,
-      });
+      let resp: Response;
+      try {
+        resp = await fetch(url, {
+          method: 'POST',
+          headers: authHeaders,
+          body,
+          signal: controller.signal,
+        });
+      } catch (error) {
+        if (isAbortError(error)) throw timeoutError(error);
+        throw error;
+      }
       clearTimeout(timer);
 
       if (resp.status >= 400) {