@lingo.dev/_sdk 0.16.4 → 0.17.0

package/build/index.cjs

@@ -114,7 +114,13 @@ var engineParamsSchema = _zod2.default.object({
   apiUrl: _zod2.default.string().url().default("https://api.lingo.dev"),
   batchSize: _zod2.default.number().int().gt(0).lte(250).default(25),
   idealBatchItemSize: _zod2.default.number().int().gt(0).lte(2500).default(250),
-  engineId: _zod2.default.string().optional()
+  engineId: _zod2.default.string().optional(),
+  // Number of times a localization request is retried after a transient
+  // failure (5xx response or network error). `0` disables retries.
+  maxRetries: _zod2.default.number().int().gte(0).default(3),
+  // Base delay (ms) for the exponential backoff between retries. The actual
+  // wait grows as `retryDelayMs * 2 ** attempt` plus a small random jitter.
+  retryDelayMs: _zod2.default.number().int().gte(0).default(500)
 }).passthrough();
 var normalizedLocaleCodeSchema = __spec.localeCodeSchema.transform(__spec.normalizeLocale);
 var payloadSchema = _zod2.default.record(_zod2.default.string(), _zod2.default.any());
@@ -129,6 +135,12 @@ var localizationParamsSchema = _zod2.default.object({
   filePath: _zod2.default.string().optional(),
   triggerType: _zod2.default.enum(["cli", "ci"]).optional()
 });
+var estimateItemsSchema = _zod2.default.array(
+  _zod2.default.object({
+    targetLocale: normalizedLocaleCodeSchema,
+    sourceChars: _zod2.default.number().int().nonnegative()
+  })
+).min(1);
 var LingoDotDevEngine = (_class = class _LingoDotDevEngine {
   
   __init() {this.sessionId = _cuid2.createId.call(void 0, )}
@@ -166,6 +178,74 @@ var LingoDotDevEngine = (_class = class _LingoDotDevEngine {
     }
     throw new Error(context ? `${context}: ${msg}` : msg);
   }
+  /**
+   * Sleep for `ms` milliseconds, rejecting early if the signal is aborted.
+   */
+  static sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+      if (_optionalChain([signal, 'optionalAccess', _4 => _4.aborted])) {
+        reject(new Error("Operation was aborted"));
+        return;
+      }
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new Error("Operation was aborted"));
+      };
+      const timer = setTimeout(() => {
+        _optionalChain([signal, 'optionalAccess', _5 => _5.removeEventListener, 'call', _6 => _6("abort", onAbort)]);
+        resolve();
+      }, ms);
+      _optionalChain([signal, 'optionalAccess', _7 => _7.addEventListener, 'call', _8 => _8("abort", onAbort, { once: true })]);
+    });
+  }
+  /**
+   * Exponential backoff with full jitter: a random delay in
+   * `[0, retryDelayMs * 2 ** attempt]`. Jitter spreads out retries from many
+   * clients so a recovering server is not hit by a synchronized wave.
+   */
+  backoffDelay(attempt) {
+    const ceiling = this.config.retryDelayMs * 2 ** attempt;
+    return Math.round(Math.random() * ceiling);
+  }
+  /**
+   * Perform a fetch, retrying on transient failures (5xx responses and
+   * network errors) with exponential backoff. The retry decision is made on
+   * the HTTP status code (>= 500), so non-retryable responses (e.g. 4xx) are
+   * returned immediately for the caller to handle. Aborted requests are never
+   * retried.
+   * @param url - The request URL
+   * @param init - Fetch init options (should include the AbortSignal)
+   * @param signal - Optional AbortSignal used to short-circuit retries
+   * @returns The fetch Response (which may still be a non-retryable error)
+   */
+  async fetchWithRetry(url, init, signal) {
+    const { maxRetries } = this.config;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (_optionalChain([signal, 'optionalAccess', _9 => _9.aborted])) {
+        throw new Error("Operation was aborted");
+      }
+      try {
+        const res = await fetch(url, init);
+        const isServerError = res.status >= 500 && res.status < 600;
+        if (isServerError && attempt < maxRetries) {
+          await _optionalChain([res, 'access', _10 => _10.body, 'optionalAccess', _11 => _11.cancel, 'call', _12 => _12()]);
+          await _LingoDotDevEngine.sleep(this.backoffDelay(attempt), signal);
+          continue;
+        }
+        return res;
+      } catch (error) {
+        if (_optionalChain([signal, 'optionalAccess', _13 => _13.aborted])) {
+          throw error;
+        }
+        if (attempt < maxRetries) {
+          await _LingoDotDevEngine.sleep(this.backoffDelay(attempt), signal);
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error("Localization request failed after exhausting retries");
+  }
   /**
    * Create a new LingoDotDevEngine instance
    * @param config - Configuration options for the Engine
@@ -233,12 +313,16 @@ var LingoDotDevEngine = (_class = class _LingoDotDevEngine {
       metadata: filePath ? { filePath } : void 0,
       ...this.config.engineId && { engineId: this.config.engineId }
     };
-    const res = await fetch(url, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(body, null, 2),
+    const res = await this.fetchWithRetry(
+      url,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(body, null, 2),
+        signal
+      },
       signal
-    });
+    );
     await _LingoDotDevEngine.throwOnHttpError(res);
     const jsonResponse = await res.json();
     if (!jsonResponse.data && jsonResponse.error) {
@@ -579,7 +663,7 @@ var LingoDotDevEngine = (_class = class _LingoDotDevEngine {
             break;
           }
           const siblings = Array.from(parent.childNodes).filter(
-            (n) => n.nodeType === 1 || n.nodeType === 3 && _optionalChain([n, 'access', _4 => _4.textContent, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()])
+            (n) => n.nodeType === 1 || n.nodeType === 3 && _optionalChain([n, 'access', _14 => _14.textContent, 'optionalAccess', _15 => _15.trim, 'call', _16 => _16()])
           );
           const index = siblings.indexOf(current);
           if (index !== -1) {
@@ -599,7 +683,7 @@ var LingoDotDevEngine = (_class = class _LingoDotDevEngine {
           parent = parent.parentElement;
         }
         if (node.nodeType === 3) {
-          const text = _optionalChain([node, 'access', _7 => _7.textContent, 'optionalAccess', _8 => _8.trim, 'call', _9 => _9()]) || "";
+          const text = _optionalChain([node, 'access', _17 => _17.textContent, 'optionalAccess', _18 => _18.trim, 'call', _19 => _19()]) || "";
           if (text) {
             extractedContent[getPath(node)] = text;
           }
@@ -614,15 +698,15 @@ var LingoDotDevEngine = (_class = class _LingoDotDevEngine {
             }
           });
           Array.from(element.childNodes).filter(
-            (n) => n.nodeType === 1 || n.nodeType === 3 && _optionalChain([n, 'access', _10 => _10.textContent, 'optionalAccess', _11 => _11.trim, 'call', _12 => _12()])
+            (n) => n.nodeType === 1 || n.nodeType === 3 && _optionalChain([n, 'access', _20 => _20.textContent, 'optionalAccess', _21 => _21.trim, 'call', _22 => _22()])
           ).forEach(processNode);
         }
       };
       Array.from(document.head.childNodes).filter(
-        (n) => n.nodeType === 1 || n.nodeType === 3 && _optionalChain([n, 'access', _13 => _13.textContent, 'optionalAccess', _14 => _14.trim, 'call', _15 => _15()])
+        (n) => n.nodeType === 1 || n.nodeType === 3 && _optionalChain([n, 'access', _23 => _23.textContent, 'optionalAccess', _24 => _24.trim, 'call', _25 => _25()])
       ).forEach(processNode);
       Array.from(document.body.childNodes).filter(
-        (n) => n.nodeType === 1 || n.nodeType === 3 && _optionalChain([n, 'access', _16 => _16.textContent, 'optionalAccess', _17 => _17.trim, 'call', _18 => _18()])
+        (n) => n.nodeType === 1 || n.nodeType === 3 && _optionalChain([n, 'access', _26 => _26.textContent, 'optionalAccess', _27 => _27.trim, 'call', _28 => _28()])
       ).forEach(processNode);
       const localizedContent = await this._localizeRaw(
         extractedContent,
@@ -638,10 +722,10 @@ var LingoDotDevEngine = (_class = class _LingoDotDevEngine {
         let current = parent;
         for (const index of indices) {
           const siblings = Array.from(parent.childNodes).filter(
-            (n) => n.nodeType === 1 || n.nodeType === 3 && _optionalChain([n, 'access', _19 => _19.textContent, 'optionalAccess', _20 => _20.trim, 'call', _21 => _21()])
+            (n) => n.nodeType === 1 || n.nodeType === 3 && _optionalChain([n, 'access', _29 => _29.textContent, 'optionalAccess', _30 => _30.trim, 'call', _31 => _31()])
           );
           current = siblings[parseInt(index)] || null;
-          if (_optionalChain([current, 'optionalAccess', _22 => _22.nodeType]) === 1) {
+          if (_optionalChain([current, 'optionalAccess', _32 => _32.nodeType]) === 1) {
             parent = current;
           }
         }
@@ -721,6 +805,27 @@ var LingoDotDevEngine = (_class = class _LingoDotDevEngine {
       throw error;
     }
   }
+  /**
+   * Estimate the cost of localizing content BEFORE submitting it.
+   * Pure computation server-side — nothing is translated, stored, or billed.
+   * @param items - Per-target-locale character counts of translatable source
+   * text (sum of source string lengths, excluding keys and markup). Duplicate
+   * locales are summed by the server.
+   * @param signal - Optional AbortSignal to cancel the operation
+   * @returns Promise resolving to an approximate cost with per-locale breakdown
+   */
+  async estimate(items, signal) {
+    const parsedItems = estimateItemsSchema.parse(items);
+    const url = `${this.config.apiUrl}/process/estimate`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ items: parsedItems }),
+      signal
+    });
+    await _LingoDotDevEngine.throwOnHttpError(res, "Error estimating cost");
+    return res.json();
+  }
   async whoami(signal) {
     const url = `${this.config.apiUrl}/users/me`;
     const res = await fetch(url, {
@@ -730,7 +835,7 @@ var LingoDotDevEngine = (_class = class _LingoDotDevEngine {
     });
     if (res.ok) {
       const payload = await res.json();
-      if (!_optionalChain([payload, 'optionalAccess', _23 => _23.email])) {
+      if (!_optionalChain([payload, 'optionalAccess', _33 => _33.email])) {
         return null;
       }
       return {

package/build/index.d.cts

@@ -7,6 +7,8 @@ declare const engineParamsSchema: Z.ZodObject<{
     batchSize: Z.ZodDefault<Z.ZodNumber>;
     idealBatchItemSize: Z.ZodDefault<Z.ZodNumber>;
     engineId: Z.ZodOptional<Z.ZodString>;
+    maxRetries: Z.ZodDefault<Z.ZodNumber>;
+    retryDelayMs: Z.ZodDefault<Z.ZodNumber>;
 }, Z.core.$loose>;
 declare const payloadSchema: Z.ZodRecord<Z.ZodString, Z.ZodAny>;
 declare const localizationParamsSchema: Z.ZodObject<{
@@ -21,6 +23,27 @@ declare const localizationParamsSchema: Z.ZodObject<{
         ci: "ci";
     }>>;
 }, Z.core.$strip>;
+/**
+ * Approximate localization cost returned by `/process/estimate`.
+ * `approximate` is always true — the estimate is a chars→tokens heuristic,
+ * not a quote. Actual cost may differ.
+ */
+type CostEstimate = {
+    approximate: boolean;
+    totals: {
+        sourceChars: number;
+        estimatedOutputTokens: number;
+        estimatedLlmCostUsd: number;
+        estimatedLocalizationCostUsd: number;
+        estimatedTotalCostUsd: number;
+    };
+    byLocale: {
+        targetLocale: string;
+        sourceChars: number;
+        estimatedOutputTokens: number;
+        estimatedCostUsd: number;
+    }[];
+};
 /**
  * LingoDotDevEngine class for interacting with the LingoDotDev API
  * A powerful localization engine that supports various content types including
@@ -32,6 +55,28 @@ declare class LingoDotDevEngine {
     private get headers();
     private static extractErrorMessage;
     private static throwOnHttpError;
+    /**
+     * Sleep for `ms` milliseconds, rejecting early if the signal is aborted.
+     */
+    private static sleep;
+    /**
+     * Exponential backoff with full jitter: a random delay in
+     * `[0, retryDelayMs * 2 ** attempt]`. Jitter spreads out retries from many
+     * clients so a recovering server is not hit by a synchronized wave.
+     */
+    private backoffDelay;
+    /**
+     * Perform a fetch, retrying on transient failures (5xx responses and
+     * network errors) with exponential backoff. The retry decision is made on
+     * the HTTP status code (>= 500), so non-retryable responses (e.g. 4xx) are
+     * returned immediately for the caller to handle. Aborted requests are never
+     * retried.
+     * @param url - The request URL
+     * @param init - Fetch init options (should include the AbortSignal)
+     * @param signal - Optional AbortSignal used to short-circuit retries
+     * @returns The fetch Response (which may still be a non-retryable error)
+     */
+    private fetchWithRetry;
     /**
      * Create a new LingoDotDevEngine instance
      * @param config - Configuration options for the Engine
@@ -158,6 +203,19 @@ declare class LingoDotDevEngine {
      * @returns Promise resolving to a locale code (e.g., 'en', 'es', 'fr')
      */
     recognizeLocale(text: string, signal?: AbortSignal): Promise<LocaleCode>;
+    /**
+     * Estimate the cost of localizing content BEFORE submitting it.
+     * Pure computation server-side — nothing is translated, stored, or billed.
+     * @param items - Per-target-locale character counts of translatable source
+     * text (sum of source string lengths, excluding keys and markup). Duplicate
+     * locales are summed by the server.
+     * @param signal - Optional AbortSignal to cancel the operation
+     * @returns Promise resolving to an approximate cost with per-locale breakdown
+     */
+    estimate(items: {
+        targetLocale: string;
+        sourceChars: number;
+    }[], signal?: AbortSignal): Promise<CostEstimate>;
     whoami(signal?: AbortSignal): Promise<{
         email: string;
         id: string;
@@ -178,4 +236,4 @@ declare class LingoEngine extends LingoDotDevEngine {
     constructor(config: Partial<Z.infer<typeof engineParamsSchema>>);
 }
 
-export { LingoDotDevEngine, LingoEngine, ReplexicaEngine };
+export { type CostEstimate, LingoDotDevEngine, LingoEngine, ReplexicaEngine };

package/build/index.d.ts

@@ -7,6 +7,8 @@ declare const engineParamsSchema: Z.ZodObject<{
     batchSize: Z.ZodDefault<Z.ZodNumber>;
     idealBatchItemSize: Z.ZodDefault<Z.ZodNumber>;
     engineId: Z.ZodOptional<Z.ZodString>;
+    maxRetries: Z.ZodDefault<Z.ZodNumber>;
+    retryDelayMs: Z.ZodDefault<Z.ZodNumber>;
 }, Z.core.$loose>;
 declare const payloadSchema: Z.ZodRecord<Z.ZodString, Z.ZodAny>;
 declare const localizationParamsSchema: Z.ZodObject<{
@@ -21,6 +23,27 @@ declare const localizationParamsSchema: Z.ZodObject<{
         ci: "ci";
     }>>;
 }, Z.core.$strip>;
+/**
+ * Approximate localization cost returned by `/process/estimate`.
+ * `approximate` is always true — the estimate is a chars→tokens heuristic,
+ * not a quote. Actual cost may differ.
+ */
+type CostEstimate = {
+    approximate: boolean;
+    totals: {
+        sourceChars: number;
+        estimatedOutputTokens: number;
+        estimatedLlmCostUsd: number;
+        estimatedLocalizationCostUsd: number;
+        estimatedTotalCostUsd: number;
+    };
+    byLocale: {
+        targetLocale: string;
+        sourceChars: number;
+        estimatedOutputTokens: number;
+        estimatedCostUsd: number;
+    }[];
+};
 /**
  * LingoDotDevEngine class for interacting with the LingoDotDev API
  * A powerful localization engine that supports various content types including
@@ -32,6 +55,28 @@ declare class LingoDotDevEngine {
     private get headers();
     private static extractErrorMessage;
     private static throwOnHttpError;
+    /**
+     * Sleep for `ms` milliseconds, rejecting early if the signal is aborted.
+     */
+    private static sleep;
+    /**
+     * Exponential backoff with full jitter: a random delay in
+     * `[0, retryDelayMs * 2 ** attempt]`. Jitter spreads out retries from many
+     * clients so a recovering server is not hit by a synchronized wave.
+     */
+    private backoffDelay;
+    /**
+     * Perform a fetch, retrying on transient failures (5xx responses and
+     * network errors) with exponential backoff. The retry decision is made on
+     * the HTTP status code (>= 500), so non-retryable responses (e.g. 4xx) are
+     * returned immediately for the caller to handle. Aborted requests are never
+     * retried.
+     * @param url - The request URL
+     * @param init - Fetch init options (should include the AbortSignal)
+     * @param signal - Optional AbortSignal used to short-circuit retries
+     * @returns The fetch Response (which may still be a non-retryable error)
+     */
+    private fetchWithRetry;
     /**
      * Create a new LingoDotDevEngine instance
      * @param config - Configuration options for the Engine
@@ -158,6 +203,19 @@ declare class LingoDotDevEngine {
      * @returns Promise resolving to a locale code (e.g., 'en', 'es', 'fr')
      */
     recognizeLocale(text: string, signal?: AbortSignal): Promise<LocaleCode>;
+    /**
+     * Estimate the cost of localizing content BEFORE submitting it.
+     * Pure computation server-side — nothing is translated, stored, or billed.
+     * @param items - Per-target-locale character counts of translatable source
+     * text (sum of source string lengths, excluding keys and markup). Duplicate
+     * locales are summed by the server.
+     * @param signal - Optional AbortSignal to cancel the operation
+     * @returns Promise resolving to an approximate cost with per-locale breakdown
+     */
+    estimate(items: {
+        targetLocale: string;
+        sourceChars: number;
+    }[], signal?: AbortSignal): Promise<CostEstimate>;
     whoami(signal?: AbortSignal): Promise<{
         email: string;
         id: string;
@@ -178,4 +236,4 @@ declare class LingoEngine extends LingoDotDevEngine {
     constructor(config: Partial<Z.infer<typeof engineParamsSchema>>);
 }
 
-export { LingoDotDevEngine, LingoEngine, ReplexicaEngine };
+export { type CostEstimate, LingoDotDevEngine, LingoEngine, ReplexicaEngine };

package/build/index.mjs

@@ -114,7 +114,13 @@ var engineParamsSchema = Z.object({
   apiUrl: Z.string().url().default("https://api.lingo.dev"),
   batchSize: Z.number().int().gt(0).lte(250).default(25),
   idealBatchItemSize: Z.number().int().gt(0).lte(2500).default(250),
-  engineId: Z.string().optional()
+  engineId: Z.string().optional(),
+  // Number of times a localization request is retried after a transient
+  // failure (5xx response or network error). `0` disables retries.
+  maxRetries: Z.number().int().gte(0).default(3),
+  // Base delay (ms) for the exponential backoff between retries. The actual
+  // wait grows as `retryDelayMs * 2 ** attempt` plus a small random jitter.
+  retryDelayMs: Z.number().int().gte(0).default(500)
 }).passthrough();
 var normalizedLocaleCodeSchema = localeCodeSchema.transform(normalizeLocale);
 var payloadSchema = Z.record(Z.string(), Z.any());
@@ -129,6 +135,12 @@ var localizationParamsSchema = Z.object({
   filePath: Z.string().optional(),
   triggerType: Z.enum(["cli", "ci"]).optional()
 });
+var estimateItemsSchema = Z.array(
+  Z.object({
+    targetLocale: normalizedLocaleCodeSchema,
+    sourceChars: Z.number().int().nonnegative()
+  })
+).min(1);
 var LingoDotDevEngine = class _LingoDotDevEngine {
   config;
   sessionId = createId();
@@ -166,6 +178,74 @@ var LingoDotDevEngine = class _LingoDotDevEngine {
     }
     throw new Error(context ? `${context}: ${msg}` : msg);
   }
+  /**
+   * Sleep for `ms` milliseconds, rejecting early if the signal is aborted.
+   */
+  static sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(new Error("Operation was aborted"));
+        return;
+      }
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new Error("Operation was aborted"));
+      };
+      const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  /**
+   * Exponential backoff with full jitter: a random delay in
+   * `[0, retryDelayMs * 2 ** attempt]`. Jitter spreads out retries from many
+   * clients so a recovering server is not hit by a synchronized wave.
+   */
+  backoffDelay(attempt) {
+    const ceiling = this.config.retryDelayMs * 2 ** attempt;
+    return Math.round(Math.random() * ceiling);
+  }
+  /**
+   * Perform a fetch, retrying on transient failures (5xx responses and
+   * network errors) with exponential backoff. The retry decision is made on
+   * the HTTP status code (>= 500), so non-retryable responses (e.g. 4xx) are
+   * returned immediately for the caller to handle. Aborted requests are never
+   * retried.
+   * @param url - The request URL
+   * @param init - Fetch init options (should include the AbortSignal)
+   * @param signal - Optional AbortSignal used to short-circuit retries
+   * @returns The fetch Response (which may still be a non-retryable error)
+   */
+  async fetchWithRetry(url, init, signal) {
+    const { maxRetries } = this.config;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (signal?.aborted) {
+        throw new Error("Operation was aborted");
+      }
+      try {
+        const res = await fetch(url, init);
+        const isServerError = res.status >= 500 && res.status < 600;
+        if (isServerError && attempt < maxRetries) {
+          await res.body?.cancel();
+          await _LingoDotDevEngine.sleep(this.backoffDelay(attempt), signal);
+          continue;
+        }
+        return res;
+      } catch (error) {
+        if (signal?.aborted) {
+          throw error;
+        }
+        if (attempt < maxRetries) {
+          await _LingoDotDevEngine.sleep(this.backoffDelay(attempt), signal);
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error("Localization request failed after exhausting retries");
+  }
   /**
    * Create a new LingoDotDevEngine instance
    * @param config - Configuration options for the Engine
@@ -233,12 +313,16 @@ var LingoDotDevEngine = class _LingoDotDevEngine {
       metadata: filePath ? { filePath } : void 0,
       ...this.config.engineId && { engineId: this.config.engineId }
     };
-    const res = await fetch(url, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(body, null, 2),
+    const res = await this.fetchWithRetry(
+      url,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(body, null, 2),
+        signal
+      },
       signal
-    });
+    );
     await _LingoDotDevEngine.throwOnHttpError(res);
     const jsonResponse = await res.json();
     if (!jsonResponse.data && jsonResponse.error) {
@@ -721,6 +805,27 @@ var LingoDotDevEngine = class _LingoDotDevEngine {
       throw error;
     }
   }
+  /**
+   * Estimate the cost of localizing content BEFORE submitting it.
+   * Pure computation server-side — nothing is translated, stored, or billed.
+   * @param items - Per-target-locale character counts of translatable source
+   * text (sum of source string lengths, excluding keys and markup). Duplicate
+   * locales are summed by the server.
+   * @param signal - Optional AbortSignal to cancel the operation
+   * @returns Promise resolving to an approximate cost with per-locale breakdown
+   */
+  async estimate(items, signal) {
+    const parsedItems = estimateItemsSchema.parse(items);
+    const url = `${this.config.apiUrl}/process/estimate`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ items: parsedItems }),
+      signal
+    });
+    await _LingoDotDevEngine.throwOnHttpError(res, "Error estimating cost");
+    return res.json();
+  }
   async whoami(signal) {
     const url = `${this.config.apiUrl}/users/me`;
     const res = await fetch(url, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingo.dev/_sdk",
-  "version": "0.16.4",
+  "version": "0.17.0",
   "description": "Lingo.dev JS SDK",
   "private": false,
   "repository": {