xapi-to 0.1.20 → 0.1.22

package/src/client.ts

@@ -26,6 +26,13 @@ export interface ClientOptions {
   apiKey?: string;
 }
 
+export interface ApiKeyApiRequestOptions {
+  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+  body?: unknown;
+  timeoutMs?: number;
+  retries?: number;
+}
+
 export class HttpError extends Error {
   constructor(
     public readonly status: number,
@@ -100,8 +107,28 @@ function parseRetryAfterMs(res: Response): number | undefined {
   return Number.isFinite(at) ? Math.max(0, at - Date.now()) : undefined;
 }
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function abortError(signal?: AbortSignal | null): Error {
+  const reason = signal?.reason;
+  return reason instanceof Error
+    ? reason
+    : new DOMException('The operation was aborted', 'AbortError');
+}
+
+function sleep(ms: number, signal?: AbortSignal | null): Promise<void> {
+  if (signal?.aborted) return Promise.reject(abortError(signal));
+  return new Promise((resolve, reject) => {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const onAbort = () => {
+      if (timer !== undefined) clearTimeout(timer);
+      signal?.removeEventListener('abort', onAbort);
+      reject(abortError(signal));
+    };
+    timer = setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
 }
 
 export async function request<T>(
@@ -138,7 +165,7 @@ export async function request<T>(
         if (isRetryableStatus(res.status) && attempt < retries) {
           await res.text().catch(() => ''); // drain body so the socket can be reused
           clearTimeout(timer);
-          await sleep(backoffDelayMs(attempt, retryAfterMs));
+          await sleep(backoffDelayMs(attempt, retryAfterMs), callerSignal);
           attempt++;
           continue;
         }
@@ -174,7 +201,7 @@ export async function request<T>(
       if (timedOut) {
         const timeoutError = new RequestTimeoutError(timeoutMs);
         if (attempt < retries) {
-          await sleep(backoffDelayMs(attempt));
+          await sleep(backoffDelayMs(attempt), callerSignal);
           attempt++;
           continue;
         }
@@ -182,7 +209,7 @@ export async function request<T>(
       }
       if (isRetryableNetworkError(e) && attempt < retries) {
         clearTimeout(timer);
-        await sleep(backoffDelayMs(attempt));
+        await sleep(backoffDelayMs(attempt), callerSignal);
         attempt++;
         continue;
       }
@@ -200,6 +227,30 @@ function headers(apiKey?: string): Record<string, string> {
   return h;
 }
 
+/** Call a scoped API-Key control-plane endpoint without exchanging for a JWT. */
+export function apiKeyApiRequest<T>(
+  apiHost: string,
+  apiKey: string,
+  path: string,
+  options: ApiKeyApiRequestOptions = {},
+): Promise<T> {
+  const method = options.method ?? 'GET';
+  const requestHeaders: Record<string, string> = { 'XAPI-KEY': apiKey };
+  if (options.body !== undefined) requestHeaders['Content-Type'] = 'application/json';
+  return request<T>(
+    `${scheme(apiHost)}://${apiHost}${path}`,
+    {
+      method,
+      headers: requestHeaders,
+      ...(options.body !== undefined
+        ? { body: JSON.stringify(options.body) }
+        : {}),
+    },
+    options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    options.retries ?? 0,
+  );
+}
+
 function baseUrl(opts: ClientOptions): string {
   return `${scheme(opts.actionHost)}://${opts.actionHost}`;
 }
@@ -632,7 +683,11 @@ export async function initiateOAuth(
   );
 }
 
-export async function listOAuthBindings(jwtToken: string, apiHost: string) {
+export async function listOAuthBindings(
+  jwtToken: string,
+  apiHost: string,
+  signal?: AbortSignal,
+) {
   return request<Array<{
     id: string;
     apiKeyId: string;
@@ -645,7 +700,7 @@ export async function listOAuthBindings(jwtToken: string, apiHost: string) {
     provider: { id: string; name: string; type: string };
   }>>(
     `${scheme(apiHost)}://${apiHost}/api/oauth/bindings`,
-    { method: 'GET', headers: jwtHeaders(jwtToken) },
+    { method: 'GET', headers: jwtHeaders(jwtToken), signal },
     DEFAULT_TIMEOUT_MS,
     IDEMPOTENT_RETRIES,
   );

package/src/sandbox-client.ts

@@ -26,6 +26,7 @@ export interface SandboxRequirements {
   gpu?: { count?: number; model?: string };
   regions?: string[];
   capabilities?: string[];
+  minContinuousRuntimeSeconds?: number;
   [key: string]: unknown;
 }
 
@@ -263,24 +264,43 @@ export async function sandboxWait(
   signal?: AbortSignal,
 ): Promise<SandboxDetail> {
   const deadline = Date.now() + timeoutMs;
+  const deadlineController = new AbortController();
+  const abortFromCaller = () => deadlineController.abort();
+  const deadlineTimer = setTimeout(() => deadlineController.abort(), Math.max(0, timeoutMs));
+  if (signal?.aborted) deadlineController.abort();
+  else signal?.addEventListener('abort', abortFromCaller, { once: true });
   let last: SandboxDetail | undefined;
-  while (Date.now() < deadline) {
-    if (signal?.aborted) throw new Error(`sandbox wait interrupted while waiting for ${wanted.join(' or ')}`);
-    last = await sandboxGet(opts, id, signal);
-    const state = String(last.observedState || '');
-    if (wanted.includes(state)) return last;
-    if (['FAILED', 'TERMINATED'].includes(state) && !wanted.includes(state)) {
-      throw new Error(`sandbox ${id} entered ${state} while waiting for ${wanted.join(' or ')}`);
+  try {
+    while (Date.now() < deadline) {
+      if (signal?.aborted) throw new Error(`sandbox wait interrupted while waiting for ${wanted.join(' or ')}`);
+      try {
+        last = await sandboxGet(opts, id, deadlineController.signal);
+      } catch (error) {
+        if (signal?.aborted) {
+          throw new Error(`sandbox wait interrupted while waiting for ${wanted.join(' or ')}`);
+        }
+        if (Date.now() >= deadline) break;
+        throw error;
+      }
+      if (Date.now() >= deadline) break;
+      const state = String(last.observedState || '');
+      if (wanted.includes(state)) return last;
+      if (['FAILED', 'TERMINATED'].includes(state) && !wanted.includes(state)) {
+        throw new Error(`sandbox ${id} entered ${state} while waiting for ${wanted.join(' or ')}`);
+      }
+      await new Promise<void>((resolve) => {
+        const done = () => {
+          clearTimeout(timer);
+          signal?.removeEventListener('abort', done);
+          resolve();
+        };
+        const timer = setTimeout(done, Math.min(intervalMs, Math.max(0, deadline - Date.now())));
+        signal?.addEventListener('abort', done, { once: true });
+      });
     }
-    await new Promise<void>((resolve) => {
-      const done = () => {
-        clearTimeout(timer);
-        signal?.removeEventListener('abort', done);
-        resolve();
-      };
-      const timer = setTimeout(done, Math.min(intervalMs, Math.max(0, deadline - Date.now())));
-      signal?.addEventListener('abort', done, { once: true });
-    });
+  } finally {
+    clearTimeout(deadlineTimer);
+    signal?.removeEventListener('abort', abortFromCaller);
   }
   throw new Error(
     `sandbox ${id} did not enter ${wanted.join(' or ')} within ${timeoutMs}ms` +