@agent-os-sdk/client 0.9.26 → 0.9.27

package/{src/client/retry.ts → dist/client/retry.js}

@@ -1,150 +1,108 @@
 /**
  * Agent OS SDK - Retry Logic
- * 
+ *
  * Enterprise-grade retry with:
  * - Exponential backoff with jitter
  * - Respect for Retry-After headers
  * - Idempotency-aware mutation retries
  * - Proper abort signal handling (no listener leaks)
  */
-
 import { AgentOsError, NetworkError, TimeoutError, RateLimitError } from "../errors/index.js";
-import type { RetryConfig } from "./config.js";
-
-/**
- * Context for retry decision-making.
- */
-export interface RetryContext {
-    /** HTTP method (GET, POST, etc.) */
-    method: string;
-
-    /** Whether the request has an idempotency key */
-    hasIdempotencyKey: boolean;
-}
-
 /**
  * Wraps an async function with retry logic.
- * 
+ *
  * IMPORTANT: Mutations (POST/PUT/PATCH/DELETE) are only retried if hasIdempotencyKey is true.
  * This prevents duplicate side effects.
- * 
+ *
  * @param fn - Function to execute (receives an AbortSignal)
  * @param config - Retry configuration
  * @param context - Request context for retry decisions
  * @param parentSignal - Optional parent AbortSignal for cancellation
  */
-export async function withRetry<T>(
-    fn: (signal: AbortSignal) => Promise<T>,
-    config: RetryConfig,
-    context: RetryContext,
-    parentSignal?: AbortSignal
-): Promise<T> {
-    let lastError: Error | undefined;
-
+export async function withRetry(fn, config, context, parentSignal) {
+    let lastError;
     for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
         // Check parent abort before each attempt
         if (parentSignal?.aborted) {
             throw new Error("Request aborted");
         }
-
         const controller = new AbortController();
-
         // Proper abort propagation without listener leak
         const onAbort = () => controller.abort();
         parentSignal?.addEventListener("abort", onAbort, { once: true });
-
         try {
             return await fn(controller.signal);
-        } catch (err) {
-            lastError = err as Error;
-
+        }
+        catch (err) {
+            lastError = err;
             // If parent aborted, don't retry
             if (controller.signal.aborted && parentSignal?.aborted) {
                 throw err;
             }
-
             // Check if this error is retryable
             if (!shouldRetry(err, config, context)) {
                 throw err;
             }
-
             // Last attempt reached
             if (attempt === config.maxRetries) {
                 throw err;
             }
-
             // Rate limit: use Retry-After if available
             if (err instanceof RateLimitError && err.retryAfterMs) {
                 await sleep(err.retryAfterMs);
                 continue;
             }
-
             // Exponential backoff with jitter
             const delay = calculateBackoff(attempt, config);
             await sleep(delay);
-        } finally {
+        }
+        finally {
             // CRITICAL: Always cleanup listener to prevent memory leak
             parentSignal?.removeEventListener("abort", onAbort);
         }
     }
-
     throw lastError ?? new Error("Retry failed");
 }
-
 /**
  * Determines if an error should trigger a retry.
  */
-function shouldRetry(
-    err: unknown,
-    config: RetryConfig,
-    context: RetryContext
-): boolean {
+function shouldRetry(err, config, context) {
     // Network and timeout errors are always retryable
     if (err instanceof NetworkError || err instanceof TimeoutError) {
         return true;
     }
-
     // Unknown errors are not retryable
     if (!(err instanceof AgentOsError)) {
         return false;
     }
-
     // Check if status code is in retryable list
     if (!config.retryableStatuses.includes(err.status)) {
         return false;
     }
-
     // CRITICAL: Only retry mutations if they have an idempotency key
     // This prevents duplicate side effects from retrying POST/PUT/PATCH/DELETE
     const isMutation = !["GET", "HEAD", "OPTIONS"].includes(context.method.toUpperCase());
     if (isMutation && !context.hasIdempotencyKey) {
         return false;
     }
-
     return true;
 }
-
 /**
  * Calculates backoff delay with exponential increase and jitter.
  */
-function calculateBackoff(attempt: number, config: RetryConfig): number {
+function calculateBackoff(attempt, config) {
     // Exponential backoff: baseDelay * 2^attempt
     const exponential = config.baseDelayMs * Math.pow(2, attempt);
-
     // Cap at max delay
     const capped = Math.min(exponential, config.maxDelayMs);
-
     // Add jitter to prevent thundering herd
     const jitter = capped * config.jitterFactor * Math.random();
-
     return Math.floor(capped + jitter);
 }
-
 /**
  * Sleep utility.
  */
-function sleep(ms: number): Promise<void> {
+function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
-
 export { sleep };

package/dist/client/sanitize.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Header Sanitization — Security layer for HTTP headers
+ *
+ * Removes control characters and enforces size limits.
+ *
+ * @see sdk-upgrade.md Section 1.4
+ */
+/**
+ * Sanitize a single header value.
+ * - Removes control characters (0x00-0x1F, 0x7F)
+ * - Truncates to MAX_LEN
+ */
+export declare function sanitizeHeader(v: string): string;
+/**
+ * Sanitize all header values in a record.
+ * Mutates in place for performance.
+ */
+export declare function sanitizeHeaders(h: Record<string, string>): Record<string, string>;
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/client/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/client/sanitize.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOjF"}

package/{src/client/sanitize.ts → dist/client/sanitize.js}

@@ -1,27 +1,24 @@
 /**
  * Header Sanitization — Security layer for HTTP headers
- * 
+ *
  * Removes control characters and enforces size limits.
- * 
+ *
  * @see sdk-upgrade.md Section 1.4
  */
-
 const MAX_LEN = 1024;
-
 /**
  * Sanitize a single header value.
  * - Removes control characters (0x00-0x1F, 0x7F)
  * - Truncates to MAX_LEN
  */
-export function sanitizeHeader(v: string): string {
+export function sanitizeHeader(v) {
     return v.replace(/[\u0000-\u001F\u007F]/g, "").slice(0, MAX_LEN);
 }
-
 /**
  * Sanitize all header values in a record.
  * Mutates in place for performance.
  */
-export function sanitizeHeaders(h: Record<string, string>): Record<string, string> {
+export function sanitizeHeaders(h) {
     for (const k in h) {
         if (Object.prototype.hasOwnProperty.call(h, k) && h[k] !== undefined) {
             h[k] = sanitizeHeader(h[k]);

package/dist/client/timeout.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Agent OS SDK - Timeout Logic
+ *
+ * Wraps async operations with per-attempt timeout.
+ * Proper abort signal propagation without listener leaks.
+ */
+/**
+ * Wraps an async function with a timeout.
+ *
+ * The timeout is per-attempt, not global. This ensures that slow attempts
+ * don't consume the entire retry budget.
+ *
+ * @param fn - Function to execute (receives an AbortSignal)
+ * @param timeoutMs - Timeout in milliseconds
+ * @param parentSignal - Optional parent AbortSignal for cancellation
+ */
+export declare function withTimeout<T>(fn: (signal: AbortSignal) => Promise<T>, timeoutMs: number, parentSignal?: AbortSignal): Promise<T>;
+/**
+ * Creates an AbortController that times out after the specified duration.
+ * Useful for creating deadline-aware operations.
+ *
+ * @param timeoutMs - Timeout in milliseconds
+ * @returns AbortController that will abort after timeout
+ */
+export declare function createTimeoutController(timeoutMs: number): AbortController;
+//# sourceMappingURL=timeout.d.ts.map

package/dist/client/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../src/client/timeout.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAC/B,EAAE,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EACvC,SAAS,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,WAAW,GAC3B,OAAO,CAAC,CAAC,CAAC,CAsBZ;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,CAI1E"}

package/{src/client/timeout.ts → dist/client/timeout.js}

@@ -1,58 +1,50 @@
 /**
  * Agent OS SDK - Timeout Logic
- * 
+ *
  * Wraps async operations with per-attempt timeout.
  * Proper abort signal propagation without listener leaks.
  */
-
 import { TimeoutError } from "../errors/index.js";
-
 /**
  * Wraps an async function with a timeout.
- * 
+ *
  * The timeout is per-attempt, not global. This ensures that slow attempts
  * don't consume the entire retry budget.
- * 
+ *
  * @param fn - Function to execute (receives an AbortSignal)
  * @param timeoutMs - Timeout in milliseconds
  * @param parentSignal - Optional parent AbortSignal for cancellation
  */
-export async function withTimeout<T>(
-    fn: (signal: AbortSignal) => Promise<T>,
-    timeoutMs: number,
-    parentSignal?: AbortSignal
-): Promise<T> {
+export async function withTimeout(fn, timeoutMs, parentSignal) {
     const controller = new AbortController();
-
     // Propagate parent abort
     const onAbort = () => controller.abort();
     parentSignal?.addEventListener("abort", onAbort, { once: true });
-
     // Set timeout
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-
     try {
         return await fn(controller.signal);
-    } catch (err) {
+    }
+    catch (err) {
         // If our timeout triggered the abort (not parent), throw TimeoutError
         if (controller.signal.aborted && !parentSignal?.aborted) {
             throw new TimeoutError(timeoutMs);
         }
         throw err;
-    } finally {
+    }
+    finally {
         clearTimeout(timeoutId);
         parentSignal?.removeEventListener("abort", onAbort);
     }
 }
-
 /**
  * Creates an AbortController that times out after the specified duration.
  * Useful for creating deadline-aware operations.
- * 
+ *
  * @param timeoutMs - Timeout in milliseconds
  * @returns AbortController that will abort after timeout
  */
-export function createTimeoutController(timeoutMs: number): AbortController {
+export function createTimeoutController(timeoutMs) {
     const controller = new AbortController();
     setTimeout(() => controller.abort(), timeoutMs);
     return controller;

package/dist/errors/factory.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Agent OS SDK - Error Factory
+ *
+ * Creates typed errors from HTTP responses.
+ * Preserves backend error codes and details for debugging.
+ */
+import { AgentOsError } from "./index.js";
+/**
+ * Creates a typed error from an HTTP response.
+ *
+ * @param response - The fetch Response object
+ * @param body - Parsed JSON body (if available)
+ * @param requestPath - The original request path (for 404 errors)
+ */
+export declare function createErrorFromResponse(response: Response, body?: {
+    code?: string;
+    message?: string;
+    detail?: string;
+    title?: string;
+    details?: unknown;
+}, requestPath?: string): AgentOsError;
+//# sourceMappingURL=factory.d.ts.map

package/dist/errors/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/errors/factory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACH,YAAY,EAUf,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACnC,QAAQ,EAAE,QAAQ,EAClB,IAAI,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,EAC9F,WAAW,CAAC,EAAE,MAAM,GACrB,YAAY,CAgEd"}

package/{src/errors/factory.ts → dist/errors/factory.js}

@@ -1,81 +1,52 @@
 /**
  * Agent OS SDK - Error Factory
- * 
+ *
  * Creates typed errors from HTTP responses.
  * Preserves backend error codes and details for debugging.
  */
-
-import {
-    AgentOsError,
-    UnauthorizedError,
-    ForbiddenError,
-    NotFoundError,
-    ConflictError,
-    ValidationError,
-    RateLimitError,
-    ServerError,
-    type FieldError,
-    type ErrorOptions,
-} from "./index.js";
-
+import { AgentOsError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, ValidationError, RateLimitError, ServerError, } from "./index.js";
 /**
  * Creates a typed error from an HTTP response.
- * 
+ *
  * @param response - The fetch Response object
  * @param body - Parsed JSON body (if available)
  * @param requestPath - The original request path (for 404 errors)
  */
-export function createErrorFromResponse(
-    response: Response,
-    body?: { code?: string; message?: string; detail?: string; title?: string; details?: unknown },
-    requestPath?: string
-): AgentOsError {
+export function createErrorFromResponse(response, body, requestPath) {
     const status = response.status;
-    const message =
-        body?.message ||
+    const message = body?.message ||
         body?.detail ||
         body?.title ||
         response.statusText ||
         `HTTP ${status}`;
     const requestId = response.headers.get("x-request-id") ?? undefined;
-    const opts: ErrorOptions = {
+    const opts = {
         requestId,
         backendCode: body?.code,
         details: body?.details,
     };
-
     switch (status) {
         case 401:
             return new UnauthorizedError(message, opts);
-
         case 403:
             return new ForbiddenError(message, opts);
-
         case 404:
             return new NotFoundError(message, requestPath, opts);
-
         case 409:
             return new ConflictError(message, opts);
-
         case 400:
         case 422:
-            return new ValidationError(
-                message,
-                status as 400 | 422,
-                parseFieldErrors(body?.details),
-                opts
-            );
-
+            return new ValidationError(message, status, parseFieldErrors(body?.details), opts);
         case 429:
             const retryAfterHeader = response.headers.get("Retry-After");
-            let retryAfterMs: number | undefined;
-
+            let retryAfterMs;
             if (retryAfterHeader) {
                 // Retry-After can be seconds or a date
                 const seconds = parseInt(retryAfterHeader, 10);
                 if (!isNaN(seconds)) {
                     retryAfterMs = seconds * 1000;
-                } else {
+                }
+                else {
                     // Try parsing as date
                     const date = new Date(retryAfterHeader);
                     if (!isNaN(date.getTime())) {
@@ -83,9 +54,7 @@ export function createErrorFromResponse(
                     }
                 }
             }
-
             return new RateLimitError(message, retryAfterMs, opts);
-
         default:
             if (status >= 500) {
                 return new ServerError(message, status, opts);
@@ -94,36 +63,29 @@ export function createErrorFromResponse(
             return new ServerError(message, status, opts);
     }
 }
-
 /**
  * Parses field errors from various backend formats.
  */
-function parseFieldErrors(details: unknown): FieldError[] | undefined {
+function parseFieldErrors(details) {
     if (!details || typeof details !== "object") {
         return undefined;
     }
-
     // Format 1: Array of { field, message } objects
     if (Array.isArray(details)) {
-        const errors = details.filter(
-            (d): d is FieldError =>
-                typeof d === "object" &&
-                d !== null &&
-                typeof d.field === "string" &&
-                typeof d.message === "string"
-        );
+        const errors = details.filter((d) => typeof d === "object" &&
+            d !== null &&
+            typeof d.field === "string" &&
+            typeof d.message === "string");
         return errors.length > 0 ? errors : undefined;
     }
-
     // Format 2: { errors: [...] }
-    if ("errors" in details && Array.isArray((details as { errors: unknown }).errors)) {
-        return parseFieldErrors((details as { errors: unknown[] }).errors);
+    if ("errors" in details && Array.isArray(details.errors)) {
+        return parseFieldErrors(details.errors);
     }
-
     // Format 3: { field: [messages] } (Rails/Django style)
     const entries = Object.entries(details);
     if (entries.every(([, v]) => Array.isArray(v))) {
-        const errors: FieldError[] = [];
+        const errors = [];
         for (const [field, messages] of entries) {
             if (Array.isArray(messages)) {
                 for (const message of messages) {
@@ -135,6 +97,5 @@ function parseFieldErrors(details: unknown): FieldError[] | undefined {
         }
         return errors.length > 0 ? errors : undefined;
     }
-
     return undefined;
 }