@gullabs/google 0.8.4 → 0.9.0

package/README.md

@@ -23,6 +23,19 @@ pnpm add @gullabs/google @gullabs/core @google/genai
 | `geminiModelDescriptors`, `gemmaModelDescriptors`, `defaultGeminiRegistry` | Built-in model descriptors + pre-built registry                                       |
 | `geminiPricingSource()`, `GEMINI_PRICING`, `TIER_FACTOR`                   | Built-in Gemini pricing snapshot and tier-factor map                                  |
 
+
+| `GoogleFileStore` | Files API: upload + poll ACTIVE + delete |
+| `FileDeleteOptions` | `{ failClosed?, signal? }` — opt-in fail-closed delete (parity with `@gullabs/xai`) |
+
+## File store delete modes
+
+`GoogleFileStore.delete` defaults to **fail-open** (errors → `onDeleteError`, resolve). Pass `{ failClosed: true }` when the host gates durable state on known success; HTTP/SDK not-found remains success (idempotent). Empty `handle.name` always throws `bad_request`.
+
+```ts
+await store.delete(handle) // fail-open
+await store.delete(handle, { failClosed: true }) // throw on non-not-found failure
+```
+
 ## Quick example
 
 ```ts

package/dist/index.cjs

@@ -2873,25 +2873,88 @@ var GoogleFileStore = class {
     }
   }
   /**
-   * Delete a single uploaded file.
-   * Errors are forwarded to `onDeleteError` and NOT rethrown.
+   * Delete a single uploaded file. Idempotent: not-found → success.
+   *
+   * Default (`failClosed` omitted/false): errors go to `onDeleteError` and
+   * resolve (P5 fail-open). With `failClosed: true`, non-not-found errors
+   * throw typed `LlmError` and `onDeleteError` is not called.
+   *
+   * Empty/blank `handle.name` always throws `bad_request`.
    */
-  async delete(handle) {
+  async delete(handle, opts) {
+    const name = handle.name;
+    if (typeof name !== "string" || name.trim() === "") {
+      throw new core.LlmError("GoogleFileHandle.name must be a non-empty string.", {
+        kind: "bad_request",
+        retryable: false,
+        provider: "google"
+      });
+    }
+    const failClosed = opts?.failClosed === true;
     try {
+      if (opts?.signal?.aborted === true) {
+        throw new core.LlmError("Google file delete aborted", {
+          kind: "aborted",
+          retryable: false,
+          provider: "google"
+        });
+      }
       const client = await this.getClient();
-      await client.delete({ name: handle.name });
+      await client.delete({ name });
     } catch (err) {
-      this.onDeleteError(handle.name, err);
+      if (isGoogleNotFoundError(err)) {
+        return;
+      }
+      const classified = err instanceof core.LlmError ? err : core.classifyError(err);
+      const withProvider = classified.provider === void 0 ? new core.LlmError(classified.message, {
+        kind: classified.kind,
+        retryable: classified.retryable,
+        ...classified.httpStatus !== void 0 ? { httpStatus: classified.httpStatus } : {},
+        ...classified.retryAfterMs !== void 0 ? { retryAfterMs: classified.retryAfterMs } : {},
+        provider: "google",
+        cause: classified.cause ?? err
+      }) : classified;
+      if (failClosed) {
+        throw withProvider;
+      }
+      this.onDeleteError(name, withProvider);
     }
   }
   /**
    * Delete multiple files.
-   * Each failure is individually forwarded to `onDeleteError`; none are thrown.
+   *
+   * Fail-open (default): `Promise.allSettled` per handle.
+   * Fail-closed: `Promise.all` — first throw rejects; in-flight siblings are
+   * not cancelled. Prefer per-handle delete when gating durable release state.
    */
-  async deleteAll(handles) {
-    await Promise.allSettled(handles.map((h) => this.delete(h)));
+  async deleteAll(handles, opts) {
+    if (opts?.failClosed === true) {
+      await Promise.all(handles.map((h) => this.delete(h, opts)));
+      return;
+    }
+    await Promise.allSettled(handles.map((h) => this.delete(h, opts)));
   }
 };
+function isGoogleNotFoundError(err) {
+  if (err instanceof core.LlmError && err.httpStatus === 404) {
+    return true;
+  }
+  if (typeof err !== "object" || err === null) {
+    return false;
+  }
+  const obj = err;
+  if (obj["status"] === 404 || obj["httpStatus"] === 404 || obj["code"] === 404) {
+    return true;
+  }
+  if (obj["status"] === "NOT_FOUND" || obj["code"] === "NOT_FOUND") {
+    return true;
+  }
+  const msg = typeof obj["message"] === "string" ? obj["message"] : "";
+  if (/not\s*found|404/i.test(msg) && /file/i.test(msg)) {
+    return true;
+  }
+  return false;
+}
 var DEFAULT_SKEW_SECONDS = 30;
 var DEFAULT_EXTENSION_SECONDS = 3600;
 async function buildCachesClient(auth) {