@tencent-ai/workbuddy-cloud-sdk 0.1.0-dev.dee063d.202608201621 → 0.1.1-dev.111acaf.202609102031

package/lib/index.js

@@ -31,6 +31,17 @@ function normalizeHttpUrl(value, field) {
   return trimmed.replace(/\/+$/, "");
 }
 __name(normalizeHttpUrl, "normalizeHttpUrl");
+function resolveEndpoint(value) {
+  if (value !== void 0 && value !== null && value !== "") {
+    return normalizeHttpUrl(value, "endpoint");
+  }
+  const origin = globalThis.location?.origin;
+  if (typeof origin !== "string" || origin === "") {
+    throw new WorkBuddyCloudConfigError("endpoint is required outside browsers (no location.origin to fall back to).");
+  }
+  return origin.replace(/\/+$/, "");
+}
+__name(resolveEndpoint, "resolveEndpoint");
 function normalizePublishableKey(publishableKey) {
   if (typeof publishableKey !== "string" || publishableKey.trim() === "") {
     throw new WorkBuddyCloudConfigError("publishableKey is required and must be a non-empty string.");
@@ -54,11 +65,11 @@ function resolveFetch(candidate) {
 __name(resolveFetch, "resolveFetch");
 function resolveRuntimeConfig(options) {
   if (!options || typeof options !== "object") {
-    throw new WorkBuddyCloudConfigError("createWorkBuddyCloud requires endpoint, oauthRelayBaseUrl and publishableKey.");
+    throw new WorkBuddyCloudConfigError("createWorkBuddyCloud requires publishableKey.");
   }
   return Object.freeze({
-    endpoint: normalizeHttpUrl(options.endpoint, "endpoint"),
-    oauthRelayBaseUrl: normalizeHttpUrl(options.oauthRelayBaseUrl, "oauthRelayBaseUrl"),
+    endpoint: resolveEndpoint(options.endpoint),
+    oauthRelayBaseUrl: options.oauthRelayBaseUrl ? normalizeHttpUrl(options.oauthRelayBaseUrl, "oauthRelayBaseUrl") : "",
     publishableKey: normalizePublishableKey(options.publishableKey),
     fetch: resolveFetch(options.fetch)
   });
@@ -102,6 +113,8 @@ var AUTH_PATHS = {
   signInWithProvider: "/v1/signin/with/provider",
   /** 本地续期端点（服务端不转发上游）。 */
   token: "/v1/token",
+  /** 小程序微信登录：本地认人后仍需用 custom 票据换取 TCB session。 */
+  loginWechat: "/v1/login-wechat",
   signOut: "/v1/user/signout",
   userMe: "/v1/user/me",
   /** 发码。 */
@@ -527,15 +540,34 @@ var AuthModule = class {
       password: credentials.password
     });
   }
+  /**
+   * 小程序 wx.login 的 code 换 Genie session。
+   * 试用与正式是两套独立小程序，必须带当前账号的 appid
+   *（`wx.getAccountInfoSync().miniProgram.appId`）。
+   */
+  async signInWithWechat(code, appid) {
+    if (!code) {
+      return fail(badRequest("signInWithWechat requires code"));
+    }
+    if (!appid) {
+      return fail(badRequest("signInWithWechat requires appid"));
+    }
+    return this.postForSession(AUTH_PATHS.loginWechat, {
+      code,
+      appid
+    });
+  }
   /**
    * 注册。
    *
    * 上游要求先完成验证码验证，所以必须带一个 `verificationToken`（来自
    * `verifyOtp`）。只有用户名+密码的注册会被上游明确拒绝。
+   *
+   * 账号标识用 `email` 或 `phone`（二选一，与发码渠道一致）。
    */
   async signUp(credentials) {
-    if (!credentials.email) {
-      return fail(badRequest("signUp requires email"));
+    if (!credentials.email && !credentials.phone) {
+      return fail(badRequest("signUp requires email or phone"));
     }
     if (!credentials.verificationToken) {
       return fail(badRequest("signUp requires a verificationToken; run sendOtp + verifyOtp first (the provider rejects username+password-only signup)"));
@@ -543,28 +575,40 @@ var AuthModule = class {
     const body = {
       verification_token: credentials.verificationToken
     };
-    body.email = credentials.email;
+    if (credentials.phone) body.phone_number = normalizePhone(credentials.phone);
+    if (credentials.email) body.email = credentials.email;
     if (credentials.password) body.password = credentials.password;
     return this.postForSession(AUTH_PATHS.signUp, body);
   }
   /**
-   * 发邮箱验证码。
+   * 发验证码（邮箱或短信，由 `credentials` 传的字段决定）。
    *
    * 这一步**不产生会话**，只返回一个 `verificationId`。发码由上游完成，
    * 我方不实现发码逻辑。
    *
    * 返回的 `isExistingUser` 决定验码之后走登录还是注册 —— 该判断由上游给出，
    * SDK 不猜。
+   *
+   * 两条渠道的请求体差异是刻意的（runtime-auth-design §3.1）：
+   * - 邮箱：`{ email, usage: 'EMAIL' }`
+   * - 手机：`{ phone_number, target: 'ANY' }` —— **不带 `usage`**（普通短信登录
+   *   发码时省略即可，上游没有对应的短信枚举值），`target: 'ANY'` 表示新老用户
+   *   都允许发码。
    */
   async sendOtp(credentials) {
-    if (!credentials.email) {
-      return fail(badRequest("sendOtp requires email"));
+    const body = {};
+    if (credentials.phone) {
+      body.phone_number = normalizePhone(credentials.phone);
+      body.target = "ANY";
+    } else if (credentials.email) {
+      body.email = credentials.email;
+      body.usage = "EMAIL";
+      if (credentials.emailRedirectTo) {
+        body.email_redirect_to = credentials.emailRedirectTo;
+      }
+    } else {
+      return fail(badRequest("sendOtp requires email or phone"));
     }
-    const body = {
-      email: credentials.email,
-      usage: "EMAIL"
-    };
-    if (credentials.emailRedirectTo) body.email_redirect_to = credentials.emailRedirectTo;
     const res = await this.request(AUTH_PATHS.verification, {
       method: "POST",
       body
@@ -589,15 +633,18 @@ var AuthModule = class {
       return fail(sent.error);
     }
     const { verificationId, isExistingUser } = sent.data;
+    const phone = credentials.phone ? normalizePhone(credentials.phone) : void 0;
     return ok({
       verificationId,
       isExistingUser,
       isUser: isExistingUser,
-      verify: /* @__PURE__ */ __name(({ token }) => this.verifyOtp({
+      verify: /* @__PURE__ */ __name(({ token, password }) => this.verifyOtp({
         verificationId,
         token,
         email: credentials.email,
-        isExistingUser
+        phone,
+        isExistingUser,
+        password
       }), "verify")
     });
   }
@@ -610,10 +657,14 @@ var AuthModule = class {
    * 走登录还是注册由 `isExistingUser` 决定（`sendOtp` 的返回值）。刻意不做
    * 「先试登录失败再试注册」的兜底：那会把「密码错」这类真实错误掩盖成一次
    * 莫名的注册尝试。
+   *
+   * 登录侧邮箱与手机号共用 `username` 字段 —— 上游 `SignInRequest.username`
+   * 承载邮箱/手机/用户名三种形态（runtime-auth-design §3.2）。
    */
   async verifyOtp(params) {
-    if (!params.verificationId || !params.token || !params.email) {
-      return fail(badRequest("verifyOtp requires verificationId, token and email"));
+    const identifier = params.phone ? normalizePhone(params.phone) : params.email ?? "";
+    if (!params.verificationId || !params.token || !identifier) {
+      return fail(badRequest("verifyOtp requires verificationId, token and either email or phone"));
     }
     const verified = await this.request(AUTH_PATHS.verificationVerify, {
       method: "POST",
@@ -632,12 +683,13 @@ var AuthModule = class {
     }
     if (params.isExistingUser) {
       return this.postForSession(AUTH_PATHS.signIn, {
-        username: params.email,
+        username: identifier,
         verification_token: verificationToken
       });
     }
     return this.signUp({
       email: params.email,
+      phone: params.phone,
       password: params.password ?? "",
       verificationToken
     });
@@ -654,8 +706,13 @@ var AuthModule = class {
    *
    * SDK 不自己跳转（不写 `location.href`）：跳转时机应由应用决定 —— 有的要
    * 先存草稿，有的在 iframe 里要开弹窗。返回 url 交调用方处置。
+   *
+   * @deprecated Google 登录已下线，新应用不应再调用该方法。
    */
   async signInWithOAuth(options) {
+    if (!this.oauthRelayBaseUrl) {
+      return fail(badRequest("signInWithOAuth requires oauthRelayBaseUrl"));
+    }
     if (options.provider !== "google") {
       return fail(badRequest("signInWithOAuth currently supports only google"));
     }
@@ -670,6 +727,8 @@ var AuthModule = class {
    *
    * 在回调落地页调一次即可。`code` 缺失时返回 `null` 数据而**不是**错误 ——
    * 落地页可能被直接访问（用户收藏了它），那不是失败。
+   *
+   * @deprecated Google 登录已下线，新应用不应再调用该方法。
    */
   async handleOAuthCallback(search) {
     const callbackInput = search ?? currentPageSearch();
@@ -904,7 +963,11 @@ var AuthModule = class {
   // ------------------------------------------------------------------
   // 内部
   // ------------------------------------------------------------------
-  /** 拼出平台 Relay 授权地址；state 由 Relay 自己签发、校验并一次性消费。 */
+  /**
+   * 拼出平台 Relay 授权地址；state 由 Relay 自己签发、校验并一次性消费。
+   *
+   * @deprecated Google 登录已下线，仅保留给存量应用的回调落地页。
+   */
   async startRelayOAuth(options, redirectTo) {
     const callback = new URL(redirectTo);
     const relay = new URL(`${this.oauthRelayBaseUrl}/authorize`);
@@ -1000,6 +1063,17 @@ function badRequest(message) {
   };
 }
 __name(badRequest, "badRequest");
+function normalizePhone(phone) {
+  const digits = phone.replace(/\D/g, "");
+  let local = digits;
+  if (local.startsWith("0086")) {
+    local = local.slice(4);
+  } else if (local.startsWith("86") && local.length === 13) {
+    local = local.slice(2);
+  }
+  return /^1\d{10}$/.test(local) ? `+86 ${local}` : phone;
+}
+__name(normalizePhone, "normalizePhone");
 function isCloudError(v) {
   return !!v && typeof v === "object" && typeof v.kind === "string";
 }
@@ -5098,9 +5172,42 @@ function pricingField(value) {
   return Object.keys(pricing).length ? pricing : void 0;
 }
 __name(pricingField, "pricingField");
+function reasoningField(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const raw = value;
+  const result = {};
+  const effort = stringField(raw.effort);
+  if (effort !== void 0) result.effort = effort;
+  const defaultEffort = stringField(raw.defaultEffort);
+  if (defaultEffort !== void 0) result.defaultEffort = defaultEffort;
+  if (Array.isArray(raw.supportedEfforts)) {
+    result.supportedEfforts = raw.supportedEfforts.filter((item) => typeof item === "string");
+  }
+  const rawSummary = stringField(raw.summary);
+  if (rawSummary !== void 0 && (rawSummary === "auto" || rawSummary === "concise" || rawSummary === "detailed")) {
+    result.summary = rawSummary;
+  }
+  const canDisable = booleanField(raw.canDisableThinking);
+  if (canDisable !== void 0) result.canDisableThinking = canDisable;
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+__name(reasoningField, "reasoningField");
 function normalizeModel(raw) {
   const id = stringField(raw.id, raw.ID);
   if (!id) return null;
+  const serverEnabled = booleanField(raw.enabled, raw.Enabled);
+  const serverDisabled = booleanField(raw.disabled, raw.Disabled);
+  let enabled;
+  let disabled;
+  if (serverEnabled !== void 0) {
+    enabled = serverEnabled;
+    if (serverDisabled !== void 0) disabled = serverDisabled;
+  } else if (serverDisabled !== void 0) {
+    disabled = serverDisabled;
+    enabled = !serverDisabled;
+  } else {
+    enabled = true;
+  }
   return {
     id,
     name: stringField(raw.name, raw.Name) ?? id,
@@ -5143,7 +5250,10 @@ function normalizeModel(raw) {
     ...capabilitiesField(raw.capabilities ?? raw.Capabilities) ? {
       capabilities: capabilitiesField(raw.capabilities ?? raw.Capabilities)
     } : {},
-    enabled: booleanField(raw.enabled, raw.Enabled) ?? true,
+    enabled,
+    ...disabled !== void 0 ? {
+      disabled
+    } : {},
     ...booleanField(raw.isDefault, raw.IsDefault) !== void 0 ? {
       isDefault: booleanField(raw.isDefault, raw.IsDefault)
     } : {},
@@ -5152,10 +5262,55 @@ function normalizeModel(raw) {
     } : {},
     ...pricingField(raw.pricing ?? raw.Pricing) ? {
       pricing: pricingField(raw.pricing ?? raw.Pricing)
+    } : {},
+    // User-specified sparse fields: preserve explicit false/0, omit only when absent.
+    ...stringField(raw.credits, raw.Credits) ? {
+      credits: stringField(raw.credits, raw.Credits)
+    } : {},
+    ...numberField(raw.maxAllowedSize, raw.MaxAllowedSize) !== void 0 ? {
+      maxAllowedSize: numberField(raw.maxAllowedSize, raw.MaxAllowedSize)
+    } : {},
+    ...booleanField(raw.disabledMultimodal, raw.DisabledMultimodal) !== void 0 ? {
+      disabledMultimodal: booleanField(raw.disabledMultimodal, raw.DisabledMultimodal)
+    } : {},
+    ...booleanField(raw.supportsImages, raw.SupportsImages) !== void 0 ? {
+      supportsImages: booleanField(raw.supportsImages, raw.SupportsImages)
+    } : {},
+    ...booleanField(raw.supportsToolCall, raw.SupportsToolCall) !== void 0 ? {
+      supportsToolCall: booleanField(raw.supportsToolCall, raw.SupportsToolCall)
+    } : {},
+    ...booleanField(raw.supportsReasoning, raw.SupportsReasoning) !== void 0 ? {
+      supportsReasoning: booleanField(raw.supportsReasoning, raw.SupportsReasoning)
+    } : {},
+    ...booleanField(raw.onlyReasoning, raw.OnlyReasoning) !== void 0 ? {
+      onlyReasoning: booleanField(raw.onlyReasoning, raw.OnlyReasoning)
+    } : {},
+    ...reasoningField(raw.reasoning ?? raw.Reasoning) ? {
+      reasoning: reasoningField(raw.reasoning ?? raw.Reasoning)
+    } : {},
+    ...numberField(raw.temperature, raw.Temperature) !== void 0 ? {
+      temperature: numberField(raw.temperature, raw.Temperature)
+    } : {},
+    ...numberField(raw.top_k, raw.Top_K) !== void 0 ? {
+      top_k: numberField(raw.top_k, raw.Top_K)
+    } : {},
+    ...numberField(raw.top_p, raw.Top_P) !== void 0 ? {
+      top_p: numberField(raw.top_p, raw.Top_P)
+    } : {},
+    ...numberField(raw.repetition_penalty, raw.Repetition_Penalty) !== void 0 ? {
+      repetition_penalty: numberField(raw.repetition_penalty, raw.Repetition_Penalty)
     } : {}
   };
 }
 __name(normalizeModel, "normalizeModel");
+function getModelDisplayName(model) {
+  return model.name || model.id;
+}
+__name(getModelDisplayName, "getModelDisplayName");
+function getModelCapability(model, capability) {
+  return model.capabilities?.[capability];
+}
+__name(getModelCapability, "getModelCapability");
 var ModelsAPI = class {
   static {
     __name(this, "ModelsAPI");
@@ -5171,8 +5326,8 @@ var ModelsAPI = class {
    *
    * `id` is the value to pass as `model` to `chat.completions.create()`.
    * Optional metadata is included only when the server explicitly provides
-   * it; absence means unknown, not unsupported. The server remains the
-   * final allowlist authority for chat requests.
+   * it; absence means unknown, not unsupported. The actual call result
+   * is determined by the response, not by the directory entry.
    */
   async list(signal) {
     let response;
@@ -5445,7 +5600,10 @@ async function* iterSSEEvents(body, signal) {
 __name(iterSSEEvents, "iterSSEEvents");
 
 // src/modules/llm/chat.ts
-function extractSSEError(data) {
+function extractSSEError(data, requestId) {
+  const init = requestId ? {
+    requestId
+  } : {};
   try {
     const parsed = JSON.parse(data);
     if (parsed && typeof parsed === "object") {
@@ -5456,7 +5614,7 @@ function extractSSEError(data) {
           type: typeof errorObj.type === "string" ? errorObj.type : "server_error",
           param: errorObj.param === void 0 ? null : errorObj.param,
           code: errorObj.code === void 0 ? null : errorObj.code
-        });
+        }, init);
       }
     }
   } catch {
@@ -5466,7 +5624,7 @@ function extractSSEError(data) {
     type: "server_error",
     param: null,
     code: null
-  });
+  }, init);
 }
 __name(extractSSEError, "extractSSEError");
 var ChatCompletionsAPI = class {
@@ -5480,72 +5638,28 @@ var ChatCompletionsAPI = class {
     this.fetch = fetch2;
   }
   create(input) {
-    if (input.stream === true) {
-      return this.createStreaming(input);
-    }
-    return this.createNonStreaming(input);
-  }
-  /**
-   * Non-streaming chat completion.
-   */
-  async createNonStreaming(input) {
-    if (input.stream_options) {
+    if (input.stream !== true) {
       throw new CloudOpenAIError({
-        message: "stream_options can only be used with stream=true",
+        message: "stream must be true; non-streaming chat completions are not supported",
         type: "invalid_request_error",
-        param: "stream_options",
-        code: "request_invalid_parameter"
-      });
-    }
-    const { signal, ...body } = input;
-    if (body.stream === void 0) {
-      delete body.stream;
-    } else {
-      body.stream = false;
-    }
-    let response;
-    try {
-      response = await this.fetch(`${this.baseUrl}/chat/completions`, {
-        method: "POST",
-        headers: {
-          Accept: "application/json",
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body),
-        signal
-      });
-    } catch (err) {
-      if (err instanceof Error && err.name === "AbortError") {
-        throw err;
-      }
-      throw new CloudOpenAIError({
-        message: `Network error: ${err?.message ?? "unknown"}`,
-        type: "server_error",
-        param: null,
-        code: "gateway_network_error"
-      }, {
-        cause: err
-      });
-    }
-    if (!response.ok) {
-      throw await httpError(response);
-    }
-    const text = await response.text();
-    try {
-      return JSON.parse(text);
-    } catch {
-      throw new CloudOpenAIError({
-        message: "Failed to parse chat completion response: invalid JSON",
-        type: "server_error",
-        param: null,
-        code: "gateway_invalid_response"
+        param: "stream",
+        code: "request_stream_required"
       });
     }
+    return this.createStreaming(input);
   }
   /**
    * Streaming chat completion — returns an async generator of chunks.
    *
    * Reads the SSE stream incrementally, yielding ChatCompletionChunk objects.
+   * `stream_options` is passed through unchanged when present.
+   *
+   * The `X-Request-Id` response header is captured and attached (as
+   * `requestId`) to every `CloudOpenAIError` thrown from within the stream:
+   * `event: error`, chunk-embedded error, JSON parse failure, and missing
+   * `[DONE]` interruption. Non-2xx HTTP errors continue to go through
+   * `httpError`, which independently extracts `X-Request-Id`.
+   *
    * Throws CloudOpenAIError on:
    * - `event: error` in the stream
    * - Stream ends without `[DONE]` (gateway_stream_interrupted)
@@ -5553,7 +5667,7 @@ var ChatCompletionsAPI = class {
    * - Caller abort (AbortSignal) — exits silently, no throw
    */
   async *createStreaming(input) {
-    const { signal, ...body } = input;
+    const { signal, conversationId, ...body } = input;
     body.stream = true;
     let response;
     try {
@@ -5561,7 +5675,10 @@ var ChatCompletionsAPI = class {
         method: "POST",
         headers: {
           Accept: "text/event-stream",
-          "Content-Type": "application/json"
+          "Content-Type": "application/json",
+          ...conversationId !== void 0 ? {
+            "X-Conversation-ID": conversationId
+          } : {}
         },
         body: JSON.stringify(body),
         signal
@@ -5588,15 +5705,18 @@ var ChatCompletionsAPI = class {
         type: "server_error",
         param: null,
         code: "gateway_invalid_response"
+      }, {
+        requestId: response.headers.get("x-request-id") ?? void 0
       });
     }
+    const requestId = response.headers.get("x-request-id") ?? void 0;
     let receivedDone = false;
     let threw = false;
     try {
       for await (const sseEvent of iterSSEEvents(response.body, signal)) {
         if (sseEvent.event === "error") {
           threw = true;
-          throw extractSSEError(sseEvent.data);
+          throw extractSSEError(sseEvent.data, requestId);
         }
         if (sseEvent.event === null || sseEvent.event === "") {
           if (sseEvent.data === SSE_DONE) {
@@ -5616,6 +5736,8 @@ var ChatCompletionsAPI = class {
               type: "server_error",
               param: null,
               code: "gateway_invalid_response"
+            }, {
+              requestId
             });
           }
           if (chunk && typeof chunk === "object" && "error" in chunk) {
@@ -5626,6 +5748,8 @@ var ChatCompletionsAPI = class {
               type: typeof errObj?.type === "string" ? errObj.type : "server_error",
               param: errObj?.param === void 0 ? null : errObj.param,
               code: errObj?.code === void 0 ? null : errObj.code
+            }, {
+              requestId
             });
           }
           yield chunk;
@@ -5644,6 +5768,8 @@ var ChatCompletionsAPI = class {
         type: "server_error",
         param: null,
         code: "gateway_stream_interrupted"
+      }, {
+        requestId
       });
     }
   }
@@ -5790,22 +5916,6 @@ var recursiveToCamel = /* @__PURE__ */ __name((item) => {
   });
   return result;
 }, "recursiveToCamel");
-var isValidBucketName = /* @__PURE__ */ __name((bucketName) => {
-  if (!bucketName || typeof bucketName !== "string") {
-    return false;
-  }
-  if (bucketName.length === 0 || bucketName.length > 100) {
-    return false;
-  }
-  if (bucketName.trim() !== bucketName) {
-    return false;
-  }
-  if (bucketName.includes("/") || bucketName.includes("\\")) {
-    return false;
-  }
-  const bucketNameRegex = /^[\w!.\*'() &$@=;:+,?-]+$/;
-  return bucketNameRegex.test(bucketName);
-}, "isValidBucketName");
 var encodeStoragePath = /* @__PURE__ */ __name((path) => path.split("/").map(encodeURIComponent).join("/"), "encodeStoragePath");
 
 // src/vendor/storage/lib/common/fetch.ts
@@ -7356,1562 +7466,32 @@ var DEFAULT_HEADERS = {
   "X-Client-Info": `storage-js/${version}`
 };
 
-// src/vendor/storage/packages/StorageBucketApi.ts
-var StorageBucketApi = class extends BaseApiClient {
+// src/modules/storage.ts
+var RUNTIME_STORAGE_BUCKET = "runtime";
+var DEFAULT_SIGNED_URL_TTL_SECONDS = 10 * 60;
+var MAX_SIGNED_URL_TTL_SECONDS = 60 * 60;
+var CloudStoragePathError = class extends Error {
   static {
-    __name(this, "StorageBucketApi");
-  }
-  constructor(url, headers = {}, fetch2, opts) {
-    const baseUrl = new URL(url);
-    if (opts?.useNewHostname) {
-      const isSupabaseHost = /supabase\.(co|in|red)$/.test(baseUrl.hostname);
-      if (isSupabaseHost && !baseUrl.hostname.includes("storage.supabase.")) {
-        baseUrl.hostname = baseUrl.hostname.replace("supabase.", "storage.supabase.");
-      }
-    }
-    const finalUrl = baseUrl.href.replace(/\/$/, "");
-    const finalHeaders = {
-      ...DEFAULT_HEADERS,
-      ...headers
-    };
-    super(finalUrl, finalHeaders, fetch2, "storage");
+    __name(this, "CloudStoragePathError");
   }
-  /**
-  * Retrieves the details of all Storage buckets within an existing project.
-  *
-  * @category Storage
-  * @subcategory File Buckets
-  * @param options Query parameters for listing buckets
-  * @param options.limit Maximum number of buckets to return
-  * @param options.offset Number of buckets to skip
-  * @param options.sortColumn Column to sort by ('id', 'name', 'created_at', 'updated_at')
-  * @param options.sortOrder Sort order ('asc' or 'desc')
-  * @param options.search Search term to filter bucket names
-  * @returns Promise with response containing array of buckets or error
-  *
-  * @example List buckets
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .listBuckets()
-  * ```
-  *
-  * @example List buckets with options
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .listBuckets({
-  *     limit: 10,
-  *     offset: 0,
-  *     sortColumn: 'created_at',
-  *     sortOrder: 'desc',
-  *     search: 'prod'
-  *   })
-  * ```
-  *
-  * @remarks
-  * - RLS policy permissions required:
-  *   - `buckets` table permissions: `select`
-  *   - `objects` table permissions: none
-  * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
-  */
-  async listBuckets(options) {
-    return this.handleOperation(async () => {
-      const queryString = this.listBucketOptionsToQueryString(options);
-      return await get(this.fetch, `${this.url}/bucket${queryString}`, {
-        headers: this.headers
-      });
-    });
+  constructor(message) {
+    super(message);
+    this.name = "CloudStoragePathError";
   }
-  /**
-  * Retrieves the details of an existing Storage bucket.
-  *
-  * @category Storage
-  * @subcategory File Buckets
-  * @param id The unique identifier of the bucket you would like to retrieve.
-  * @returns Promise with response containing bucket details or error
-  *
-  * @example Get bucket
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .getBucket('avatars')
-  * ```
-  *
-  * Response:
-  * ```json
-  * {
-  *   "data": {
-  *     "id": "avatars",
-  *     "name": "avatars",
-  *     "owner": "",
-  *     "public": false,
-  *     "file_size_limit": 1024,
-  *     "allowed_mime_types": [
-  *       "image/png"
-  *     ],
-  *     "created_at": "2024-05-22T22:26:05.100Z",
-  *     "updated_at": "2024-05-22T22:26:05.100Z"
-  *   },
-  *   "error": null
-  * }
-  * ```
-  *
-  * @remarks
-  * - RLS policy permissions required:
-  *   - `buckets` table permissions: `select`
-  *   - `objects` table permissions: none
-  * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
-  */
-  async getBucket(id) {
-    return this.handleOperation(async () => {
-      return await get(this.fetch, `${this.url}/bucket/${id}`, {
-        headers: this.headers
-      });
-    });
+};
+var WorkBuddyStorageDownload = class {
+  static {
+    __name(this, "WorkBuddyStorageDownload");
   }
-  /**
-  * Creates a new Storage bucket
-  *
-  * @category Storage
-  * @subcategory File Buckets
-  * @param id A unique identifier for the bucket you are creating.
-  * @param options.public The visibility of the bucket. Public buckets don't require an authorization token to download objects, but still require a valid token for all other operations. By default, buckets are private.
-  * @param options.fileSizeLimit specifies the max file size in bytes that can be uploaded to this bucket.
-  * The global file size limit takes precedence over this value.
-  * The default value is null, which doesn't set a per bucket file size limit.
-  * @param options.allowedMimeTypes specifies the allowed mime types that this bucket can accept during upload.
-  * The default value is null, which allows files with all mime types to be uploaded.
-  * Each mime type specified can be a wildcard, e.g. image/*, or a specific mime type, e.g. image/png.
-  * @param options.type (private-beta) specifies the bucket type. see `BucketType` for more details.
-  *   - default bucket type is `STANDARD`
-  * @returns Promise with response containing newly created bucket name or error
-  *
-  * @example Create bucket
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .createBucket('avatars', {
-  *     public: false,
-  *     allowedMimeTypes: ['image/png'],
-  *     fileSizeLimit: 1024
-  *   })
-  * ```
-  *
-  * Response:
-  * ```json
-  * {
-  *   "data": {
-  *     "name": "avatars"
-  *   },
-  *   "error": null
-  * }
-  * ```
-  *
-  * @remarks
-  * - RLS policy permissions required:
-  *   - `buckets` table permissions: `insert`
-  *   - `objects` table permissions: none
-  * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
-  */
-  async createBucket(id, options = {
-    public: false
-  }) {
-    return this.handleOperation(async () => {
-      return await post(this.fetch, `${this.url}/bucket`, {
-        id,
-        name: id,
-        type: options.type,
-        public: options.public,
-        file_size_limit: options.fileSizeLimit,
-        allowed_mime_types: options.allowedMimeTypes
-      }, {
-        headers: this.headers
-      });
-    });
+  blob;
+  stream;
+  [Symbol.toStringTag] = "WorkBuddyStorageDownload";
+  constructor(blob, stream) {
+    this.blob = blob;
+    this.stream = stream;
   }
-  /**
-  * Updates a Storage bucket
-  *
-  * @category Storage
-  * @subcategory File Buckets
-  * @param id A unique identifier for the bucket you are updating.
-  * @param options.public The visibility of the bucket. Public buckets don't require an authorization token to download objects, but still require a valid token for all other operations.
-  * @param options.fileSizeLimit specifies the max file size in bytes that can be uploaded to this bucket.
-  * The global file size limit takes precedence over this value.
-  * The default value is null, which doesn't set a per bucket file size limit.
-  * @param options.allowedMimeTypes specifies the allowed mime types that this bucket can accept during upload.
-  * The default value is null, which allows files with all mime types to be uploaded.
-  * Each mime type specified can be a wildcard, e.g. image/*, or a specific mime type, e.g. image/png.
-  * @returns Promise with response containing success message or error
-  *
-  * @example Update bucket
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .updateBucket('avatars', {
-  *     public: false,
-  *     allowedMimeTypes: ['image/png'],
-  *     fileSizeLimit: 1024
-  *   })
-  * ```
-  *
-  * Response:
-  * ```json
-  * {
-  *   "data": {
-  *     "message": "Successfully updated"
-  *   },
-  *   "error": null
-  * }
-  * ```
-  *
-  * @remarks
-  * - RLS policy permissions required:
-  *   - `buckets` table permissions: `select` and `update`
-  *   - `objects` table permissions: none
-  * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
-  */
-  async updateBucket(id, options) {
-    return this.handleOperation(async () => {
-      return await put(this.fetch, `${this.url}/bucket/${id}`, {
-        id,
-        name: id,
-        public: options.public,
-        file_size_limit: options.fileSizeLimit,
-        allowed_mime_types: options.allowedMimeTypes
-      }, {
-        headers: this.headers
-      });
-    });
-  }
-  /**
-  * Removes all objects inside a single bucket.
-  *
-  * @category Storage
-  * @subcategory File Buckets
-  * @param id The unique identifier of the bucket you would like to empty.
-  * @returns Promise with success message or error
-  *
-  * @example Empty bucket
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .emptyBucket('avatars')
-  * ```
-  *
-  * Response:
-  * ```json
-  * {
-  *   "data": {
-  *     "message": "Successfully emptied"
-  *   },
-  *   "error": null
-  * }
-  * ```
-  *
-  * @remarks
-  * - RLS policy permissions required:
-  *   - `buckets` table permissions: `select`
-  *   - `objects` table permissions: `select` and `delete`
-  * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
-  */
-  async emptyBucket(id) {
-    return this.handleOperation(async () => {
-      return await post(this.fetch, `${this.url}/bucket/${id}/empty`, {}, {
-        headers: this.headers
-      });
-    });
-  }
-  /**
-  * Deletes an existing bucket. A bucket can't be deleted with existing objects inside it.
-  * You must first `empty()` the bucket.
-  *
-  * @category Storage
-  * @subcategory File Buckets
-  * @param id The unique identifier of the bucket you would like to delete.
-  * @returns Promise with success message or error
-  *
-  * @example Delete bucket
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .deleteBucket('avatars')
-  * ```
-  *
-  * Response:
-  * ```json
-  * {
-  *   "data": {
-  *     "message": "Successfully deleted"
-  *   },
-  *   "error": null
-  * }
-  * ```
-  *
-  * @remarks
-  * - RLS policy permissions required:
-  *   - `buckets` table permissions: `select` and `delete`
-  *   - `objects` table permissions: none
-  * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
-  */
-  async deleteBucket(id) {
-    return this.handleOperation(async () => {
-      return await remove(this.fetch, `${this.url}/bucket/${id}`, {}, {
-        headers: this.headers
-      });
-    });
-  }
-  /**
-  * Purges the CDN cache for an entire bucket.
-  *
-  * Maps to `DELETE /cdn/{bucket}` on the Storage API. The server
-  * issues a CDN invalidation for the bucket and returns `{ message: 'success' }`.
-  *
-  * **Requires the `service_role` key.** The underlying endpoint enforces
-  * `service_role` JWT — calls made with the anon key or a user JWT will be
-  * rejected by the server.
-  *
-  * **Hosted CDN feature.** On self-hosted Supabase, the Storage service must
-  * have `CDN_PURGE_ENDPOINT_URL` configured and the `purgeCache` tenant
-  * feature enabled, otherwise the server returns an error.
-  *
-  * @category Storage
-  * @subcategory File Buckets
-  * @param id The unique identifier of the bucket you would like to purge from cache.
-  * @param options Optional purge cache options.
-  * @param options.transformations If true, purges only transformations (resized/formatted variants), leaving original cached files intact.
-  * @param parameters Optional fetch parameters such as an `AbortController` signal.
-  * @returns Promise with `{ data: { message }, error: null }` on success or `{ data: null, error }` on failure.
-  *
-  * @example Purge cache for an entire bucket
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .purgeBucketCache('avatars')
-  * ```
-  *
-  * @example Purge only transformations for an entire bucket
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .purgeBucketCache('avatars', { transformations: true })
-  * ```
-  */
-  async purgeBucketCache(id, options, parameters) {
-    return this.handleOperation(async () => {
-      const query = new URLSearchParams();
-      if (options?.transformations) {
-        query.set("transformations", "true");
-      }
-      const queryString = query.toString();
-      return await remove(this.fetch, `${this.url}/cdn/${encodeStoragePath(id)}${queryString ? `?${queryString}` : ""}`, {}, {
-        headers: this.headers
-      }, parameters);
-    });
-  }
-  listBucketOptionsToQueryString(options) {
-    const params = {};
-    if (options) {
-      if ("limit" in options) {
-        params.limit = String(options.limit);
-      }
-      if ("offset" in options) {
-        params.offset = String(options.offset);
-      }
-      if (options.search) {
-        params.search = options.search;
-      }
-      if (options.sortColumn) {
-        params.sortColumn = options.sortColumn;
-      }
-      if (options.sortOrder) {
-        params.sortOrder = options.sortOrder;
-      }
-    }
-    return Object.keys(params).length > 0 ? "?" + new URLSearchParams(params).toString() : "";
-  }
-};
-
-// src/vendor/storage/packages/StorageAnalyticsClient.ts
-import { IcebergRestCatalog } from "iceberg-js";
-var StorageAnalyticsClient = class extends BaseApiClient {
-  static {
-    __name(this, "StorageAnalyticsClient");
-  }
-  /**
-  * @alpha
-  *
-  * Creates a new StorageAnalyticsClient instance
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Analytics Buckets
-  * @param url - The base URL for the storage API
-  * @param headers - HTTP headers to include in requests
-  * @param fetch - Optional custom fetch implementation
-  *
-  * @example Using supabase-js (recommended)
-  * ```typescript
-  * import { createClient } from '@supabase/supabase-js'
-  *
-  * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
-  * const { data, error } = await supabase.storage.analytics.listBuckets()
-  * ```
-  *
-  * @example Standalone import for bundle-sensitive environments
-  * ```typescript
-  * import { StorageAnalyticsClient } from '@supabase/storage-js'
-  *
-  * const client = new StorageAnalyticsClient(url, headers)
-  * ```
-  */
-  constructor(url, headers = {}, fetch2) {
-    const finalUrl = url.replace(/\/$/, "");
-    const finalHeaders = {
-      ...DEFAULT_HEADERS,
-      ...headers
-    };
-    super(finalUrl, finalHeaders, fetch2, "storage");
-  }
-  /**
-  * @alpha
-  *
-  * Creates a new analytics bucket using Iceberg tables
-  * Analytics buckets are optimized for analytical queries and data processing
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Analytics Buckets
-  * @param name A unique name for the bucket you are creating
-  * @returns Promise with response containing newly created analytics bucket or error
-  *
-  * @example Create analytics bucket
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .analytics
-  *   .createBucket('analytics-data')
-  * ```
-  *
-  * Response:
-  * ```json
-  * {
-  *   "data": {
-  *     "name": "analytics-data",
-  *     "type": "ANALYTICS",
-  *     "format": "iceberg",
-  *     "created_at": "2024-05-22T22:26:05.100Z",
-  *     "updated_at": "2024-05-22T22:26:05.100Z"
-  *   },
-  *   "error": null
-  * }
-  * ```
-  *
-  * @remarks
-  * - Creates a new analytics bucket using Iceberg tables
-  * - Analytics buckets are optimized for analytical queries and data processing
-  */
-  async createBucket(name) {
-    return this.handleOperation(async () => {
-      return await post(this.fetch, `${this.url}/bucket`, {
-        name
-      }, {
-        headers: this.headers
-      });
-    });
-  }
-  /**
-  * @alpha
-  *
-  * Retrieves the details of all Analytics Storage buckets within an existing project
-  * Only returns buckets of type 'ANALYTICS'
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Analytics Buckets
-  * @param options Query parameters for listing buckets
-  * @param options.limit Maximum number of buckets to return
-  * @param options.offset Number of buckets to skip
-  * @param options.sortColumn Column to sort by ('name', 'created_at', 'updated_at')
-  * @param options.sortOrder Sort order ('asc' or 'desc')
-  * @param options.search Search term to filter bucket names
-  * @returns Promise with response containing array of analytics buckets or error
-  *
-  * @example List analytics buckets
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .analytics
-  *   .listBuckets({
-  *     limit: 10,
-  *     offset: 0,
-  *     sortColumn: 'created_at',
-  *     sortOrder: 'desc'
-  *   })
-  * ```
-  *
-  * Response:
-  * ```json
-  * {
-  *   "data": [
-  *     {
-  *       "name": "analytics-data",
-  *       "type": "ANALYTICS",
-  *       "format": "iceberg",
-  *       "created_at": "2024-05-22T22:26:05.100Z",
-  *       "updated_at": "2024-05-22T22:26:05.100Z"
-  *     }
-  *   ],
-  *   "error": null
-  * }
-  * ```
-  *
-  * @remarks
-  * - Retrieves the details of all Analytics Storage buckets within an existing project
-  * - Only returns buckets of type 'ANALYTICS'
-  */
-  async listBuckets(options) {
-    return this.handleOperation(async () => {
-      const queryParams = new URLSearchParams();
-      if (options?.limit !== void 0) queryParams.set("limit", options.limit.toString());
-      if (options?.offset !== void 0) queryParams.set("offset", options.offset.toString());
-      if (options?.sortColumn) queryParams.set("sortColumn", options.sortColumn);
-      if (options?.sortOrder) queryParams.set("sortOrder", options.sortOrder);
-      if (options?.search) queryParams.set("search", options.search);
-      const queryString = queryParams.toString();
-      const url = queryString ? `${this.url}/bucket?${queryString}` : `${this.url}/bucket`;
-      return await get(this.fetch, url, {
-        headers: this.headers
-      });
-    });
-  }
-  /**
-  * @alpha
-  *
-  * Deletes an existing analytics bucket
-  * A bucket can't be deleted with existing objects inside it
-  * You must first empty the bucket before deletion
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Analytics Buckets
-  * @param bucketName The unique identifier of the bucket you would like to delete
-  * @returns Promise with response containing success message or error
-  *
-  * @example Delete analytics bucket
-  * ```js
-  * const { data, error } = await supabase
-  *   .storage
-  *   .analytics
-  *   .deleteBucket('analytics-data')
-  * ```
-  *
-  * Response:
-  * ```json
-  * {
-  *   "data": {
-  *     "message": "Successfully deleted"
-  *   },
-  *   "error": null
-  * }
-  * ```
-  *
-  * @remarks
-  * - Deletes an analytics bucket
-  */
-  async deleteBucket(bucketName) {
-    return this.handleOperation(async () => {
-      return await remove(this.fetch, `${this.url}/bucket/${bucketName}`, {}, {
-        headers: this.headers
-      });
-    });
-  }
-  /**
-  * @alpha
-  *
-  * Get an Iceberg REST Catalog client configured for a specific analytics bucket
-  * Use this to perform advanced table and namespace operations within the bucket
-  * The returned client provides full access to the Apache Iceberg REST Catalog API
-  * with the Supabase `{ data, error }` pattern for consistent error handling on all operations.
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Analytics Buckets
-  * @param bucketName - The name of the analytics bucket (warehouse) to connect to
-  * @returns The wrapped Iceberg catalog client
-  * @throws {StorageError} If the bucket name is invalid
-  *
-  * @example Get catalog and create table
-  * ```js
-  * // First, create an analytics bucket
-  * const { data: bucket, error: bucketError } = await supabase
-  *   .storage
-  *   .analytics
-  *   .createBucket('analytics-data')
-  *
-  * // Get the Iceberg catalog for that bucket
-  * const catalog = supabase.storage.analytics.from('analytics-data')
-  *
-  * // Create a namespace
-  * const { error: nsError } = await catalog.createNamespace({ namespace: ['default'] })
-  *
-  * // Create a table with schema
-  * const { data: tableMetadata, error: tableError } = await catalog.createTable(
-  *   { namespace: ['default'] },
-  *   {
-  *     name: 'events',
-  *     schema: {
-  *       type: 'struct',
-  *       fields: [
-  *         { id: 1, name: 'id', type: 'long', required: true },
-  *         { id: 2, name: 'timestamp', type: 'timestamp', required: true },
-  *         { id: 3, name: 'user_id', type: 'string', required: false }
-  *       ],
-  *       'schema-id': 0,
-  *       'identifier-field-ids': [1]
-  *     },
-  *     'partition-spec': {
-  *       'spec-id': 0,
-  *       fields: []
-  *     },
-  *     'write-order': {
-  *       'order-id': 0,
-  *       fields: []
-  *     },
-  *     properties: {
-  *       'write.format.default': 'parquet'
-  *     }
-  *   }
-  * )
-  * ```
-  *
-  * @example List tables in namespace
-  * ```js
-  * const catalog = supabase.storage.analytics.from('analytics-data')
-  *
-  * // List all tables in the default namespace
-  * const { data: tables, error: listError } = await catalog.listTables({ namespace: ['default'] })
-  * if (listError) {
-  *   if (listError.isNotFound()) {
-  *     console.log('Namespace not found')
-  *   }
-  *   return
-  * }
-  * console.log(tables) // [{ namespace: ['default'], name: 'events' }]
-  * ```
-  *
-  * @example Working with namespaces
-  * ```js
-  * const catalog = supabase.storage.analytics.from('analytics-data')
-  *
-  * // List all namespaces
-  * const { data: namespaces } = await catalog.listNamespaces()
-  *
-  * // Create namespace with properties
-  * await catalog.createNamespace(
-  *   { namespace: ['production'] },
-  *   { properties: { owner: 'data-team', env: 'prod' } }
-  * )
-  * ```
-  *
-  * @example Cleanup operations
-  * ```js
-  * const catalog = supabase.storage.analytics.from('analytics-data')
-  *
-  * // Drop table with purge option (removes all data)
-  * const { error: dropError } = await catalog.dropTable(
-  *   { namespace: ['default'], name: 'events' },
-  *   { purge: true }
-  * )
-  *
-  * if (dropError?.isNotFound()) {
-  *   console.log('Table does not exist')
-  * }
-  *
-  * // Drop namespace (must be empty)
-  * await catalog.dropNamespace({ namespace: ['default'] })
-  * ```
-  *
-  * @remarks
-  * This method provides a bridge between Supabase's bucket management and the standard
-  * Apache Iceberg REST Catalog API. The bucket name maps to the Iceberg warehouse parameter.
-  * All authentication and configuration is handled automatically using your Supabase credentials.
-  *
-  * **Error Handling**: Invalid bucket names throw immediately. All catalog
-  * operations return `{ data, error }` where errors are `IcebergError` instances from iceberg-js.
-  * Use helper methods like `error.isNotFound()` or check `error.status` for specific error handling.
-  * Use `.throwOnError()` on the analytics client if you prefer exceptions for catalog operations.
-  *
-  * **Cleanup Operations**: When using `dropTable`, the `purge: true` option permanently
-  * deletes all table data. Without it, the table is marked as deleted but data remains.
-  *
-  * **Library Dependency**: The returned catalog wraps `IcebergRestCatalog` from iceberg-js.
-  * For complete API documentation and advanced usage, refer to the
-  * [iceberg-js documentation](https://supabase.github.io/iceberg-js/).
-  */
-  from(bucketName) {
-    if (!isValidBucketName(bucketName)) {
-      throw new StorageError("Invalid bucket name: File, folder, and bucket names must follow AWS object key naming guidelines and should avoid the use of any other characters.");
-    }
-    const catalog = new IcebergRestCatalog({
-      baseUrl: this.url,
-      catalogName: bucketName,
-      auth: {
-        type: "custom",
-        getHeaders: /* @__PURE__ */ __name(async () => this.headers, "getHeaders")
-      },
-      fetch: this.fetch
-    });
-    const shouldThrowOnError = this.shouldThrowOnError;
-    const wrappedCatalog = new Proxy(catalog, {
-      get(target, prop) {
-        const value = target[prop];
-        if (typeof value !== "function") {
-          return value;
-        }
-        return async (...args) => {
-          try {
-            const data = await value.apply(target, args);
-            return {
-              data,
-              error: null
-            };
-          } catch (error) {
-            if (shouldThrowOnError) {
-              throw error;
-            }
-            return {
-              data: null,
-              error
-            };
-          }
-        };
-      }
-    });
-    return wrappedCatalog;
-  }
-};
-
-// src/vendor/storage/packages/VectorIndexApi.ts
-var VectorIndexApi = class extends BaseApiClient {
-  static {
-    __name(this, "VectorIndexApi");
-  }
-  /** Creates a new VectorIndexApi instance */
-  constructor(url, headers = {}, fetch2) {
-    const finalUrl = url.replace(/\/$/, "");
-    const finalHeaders = {
-      ...DEFAULT_HEADERS,
-      "Content-Type": "application/json",
-      ...headers
-    };
-    super(finalUrl, finalHeaders, fetch2, "vectors");
-  }
-  /** Creates a new vector index within a bucket */
-  async createIndex(options) {
-    return this.handleOperation(async () => {
-      const data = await vectorsApi.post(this.fetch, `${this.url}/CreateIndex`, options, {
-        headers: this.headers
-      });
-      return data || {};
-    });
-  }
-  /** Retrieves metadata for a specific vector index */
-  async getIndex(vectorBucketName, indexName) {
-    return this.handleOperation(async () => {
-      return await vectorsApi.post(this.fetch, `${this.url}/GetIndex`, {
-        vectorBucketName,
-        indexName
-      }, {
-        headers: this.headers
-      });
-    });
-  }
-  /** Lists vector indexes within a bucket with optional filtering and pagination */
-  async listIndexes(options) {
-    return this.handleOperation(async () => {
-      return await vectorsApi.post(this.fetch, `${this.url}/ListIndexes`, options, {
-        headers: this.headers
-      });
-    });
-  }
-  /** Deletes a vector index and all its data */
-  async deleteIndex(vectorBucketName, indexName) {
-    return this.handleOperation(async () => {
-      const data = await vectorsApi.post(this.fetch, `${this.url}/DeleteIndex`, {
-        vectorBucketName,
-        indexName
-      }, {
-        headers: this.headers
-      });
-      return data || {};
-    });
-  }
-};
-
-// src/vendor/storage/packages/VectorDataApi.ts
-var VectorDataApi = class extends BaseApiClient {
-  static {
-    __name(this, "VectorDataApi");
-  }
-  /** Creates a new VectorDataApi instance */
-  constructor(url, headers = {}, fetch2) {
-    const finalUrl = url.replace(/\/$/, "");
-    const finalHeaders = {
-      ...DEFAULT_HEADERS,
-      "Content-Type": "application/json",
-      ...headers
-    };
-    super(finalUrl, finalHeaders, fetch2, "vectors");
-  }
-  /** Inserts or updates vectors in batch (1-500 per request) */
-  async putVectors(options) {
-    if (options.vectors.length < 1 || options.vectors.length > 500) {
-      throw new Error("Vector batch size must be between 1 and 500 items");
-    }
-    return this.handleOperation(async () => {
-      const data = await vectorsApi.post(this.fetch, `${this.url}/PutVectors`, options, {
-        headers: this.headers
-      });
-      return data || {};
-    });
-  }
-  /** Retrieves vectors by their keys in batch */
-  async getVectors(options) {
-    return this.handleOperation(async () => {
-      return await vectorsApi.post(this.fetch, `${this.url}/GetVectors`, options, {
-        headers: this.headers
-      });
-    });
-  }
-  /** Lists vectors in an index with pagination */
-  async listVectors(options) {
-    if (options.segmentCount !== void 0) {
-      if (options.segmentCount < 1 || options.segmentCount > 16) {
-        throw new Error("segmentCount must be between 1 and 16");
-      }
-      if (options.segmentIndex !== void 0) {
-        if (options.segmentIndex < 0 || options.segmentIndex >= options.segmentCount) {
-          throw new Error(`segmentIndex must be between 0 and ${options.segmentCount - 1}`);
-        }
-      }
-    }
-    return this.handleOperation(async () => {
-      return await vectorsApi.post(this.fetch, `${this.url}/ListVectors`, options, {
-        headers: this.headers
-      });
-    });
-  }
-  /** Queries for similar vectors using approximate nearest neighbor search */
-  async queryVectors(options) {
-    return this.handleOperation(async () => {
-      return await vectorsApi.post(this.fetch, `${this.url}/QueryVectors`, options, {
-        headers: this.headers
-      });
-    });
-  }
-  /** Deletes vectors by their keys in batch (1-500 per request) */
-  async deleteVectors(options) {
-    if (options.keys.length < 1 || options.keys.length > 500) {
-      throw new Error("Keys batch size must be between 1 and 500 items");
-    }
-    return this.handleOperation(async () => {
-      const data = await vectorsApi.post(this.fetch, `${this.url}/DeleteVectors`, options, {
-        headers: this.headers
-      });
-      return data || {};
-    });
-  }
-};
-
-// src/vendor/storage/packages/VectorBucketApi.ts
-var VectorBucketApi = class extends BaseApiClient {
-  static {
-    __name(this, "VectorBucketApi");
-  }
-  /** Creates a new VectorBucketApi instance */
-  constructor(url, headers = {}, fetch2) {
-    const finalUrl = url.replace(/\/$/, "");
-    const finalHeaders = {
-      ...DEFAULT_HEADERS,
-      "Content-Type": "application/json",
-      ...headers
-    };
-    super(finalUrl, finalHeaders, fetch2, "vectors");
-  }
-  /** Creates a new vector bucket */
-  async createBucket(vectorBucketName) {
-    return this.handleOperation(async () => {
-      const data = await vectorsApi.post(this.fetch, `${this.url}/CreateVectorBucket`, {
-        vectorBucketName
-      }, {
-        headers: this.headers
-      });
-      return data || {};
-    });
-  }
-  /** Retrieves metadata for a specific vector bucket */
-  async getBucket(vectorBucketName) {
-    return this.handleOperation(async () => {
-      return await vectorsApi.post(this.fetch, `${this.url}/GetVectorBucket`, {
-        vectorBucketName
-      }, {
-        headers: this.headers
-      });
-    });
-  }
-  /** Lists vector buckets with optional filtering and pagination */
-  async listBuckets(options = {}) {
-    return this.handleOperation(async () => {
-      return await vectorsApi.post(this.fetch, `${this.url}/ListVectorBuckets`, options, {
-        headers: this.headers
-      });
-    });
-  }
-  /** Deletes a vector bucket (must be empty first) */
-  async deleteBucket(vectorBucketName) {
-    return this.handleOperation(async () => {
-      const data = await vectorsApi.post(this.fetch, `${this.url}/DeleteVectorBucket`, {
-        vectorBucketName
-      }, {
-        headers: this.headers
-      });
-      return data || {};
-    });
-  }
-};
-
-// src/vendor/storage/packages/StorageVectorsClient.ts
-var StorageVectorsClient = class extends VectorBucketApi {
-  static {
-    __name(this, "StorageVectorsClient");
-  }
-  /**
-  * @alpha
-  *
-  * Creates a StorageVectorsClient that can manage buckets, indexes, and vectors.
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param url - Base URL of the Storage Vectors REST API.
-  * @param options.headers - Optional headers (for example `Authorization`) applied to every request.
-  * @param options.fetch - Optional custom `fetch` implementation for non-browser runtimes.
-  *
-  * @example Using supabase-js (recommended)
-  * ```typescript
-  * import { createClient } from '@supabase/supabase-js'
-  *
-  * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
-  * const bucket = supabase.storage.vectors.from('embeddings-prod')
-  * ```
-  *
-  * @example Standalone import for bundle-sensitive environments
-  * ```typescript
-  * import { StorageVectorsClient } from '@supabase/storage-js'
-  *
-  * const client = new StorageVectorsClient(url, options)
-  * ```
-  */
-  constructor(url, options = {}) {
-    super(url, options.headers || {}, options.fetch);
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Access operations for a specific vector bucket
-  * Returns a scoped client for index and vector operations within the bucket
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param vectorBucketName - Name of the vector bucket
-  * @returns Bucket-scoped client with index and vector operations
-  *
-  * @example Accessing a vector bucket
-  * ```typescript
-  * const bucket = supabase.storage.vectors.from('embeddings-prod')
-  * ```
-  */
-  from(vectorBucketName) {
-    return new VectorBucketScope(this.url, this.headers, vectorBucketName, this.fetch);
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Creates a new vector bucket
-  * Vector buckets are containers for vector indexes and their data
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param vectorBucketName - Unique name for the vector bucket
-  * @returns Promise with empty response on success or error
-  *
-  * @example Creating a vector bucket
-  * ```typescript
-  * const { data, error } = await supabase
-  *   .storage
-  *   .vectors
-  *   .createBucket('embeddings-prod')
-  * ```
-  */
-  async createBucket(vectorBucketName) {
-    return super.createBucket(vectorBucketName);
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Retrieves metadata for a specific vector bucket
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param vectorBucketName - Name of the vector bucket
-  * @returns Promise with bucket metadata or error
-  *
-  * @example Get bucket metadata
-  * ```typescript
-  * const { data, error } = await supabase
-  *   .storage
-  *   .vectors
-  *   .getBucket('embeddings-prod')
-  *
-  * console.log('Bucket created:', data?.vectorBucket.creationTime)
-  * ```
-  */
-  async getBucket(vectorBucketName) {
-    return super.getBucket(vectorBucketName);
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Lists all vector buckets with optional filtering and pagination
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param options - Optional filters (prefix, maxResults, nextToken)
-  * @returns Promise with list of buckets or error
-  *
-  * @example List vector buckets
-  * ```typescript
-  * const { data, error } = await supabase
-  *   .storage
-  *   .vectors
-  *   .listBuckets({ prefix: 'embeddings-' })
-  *
-  * data?.vectorBuckets.forEach(bucket => {
-  *   console.log(bucket.vectorBucketName)
-  * })
-  * ```
-  */
-  async listBuckets(options = {}) {
-    return super.listBuckets(options);
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Deletes a vector bucket (bucket must be empty)
-  * All indexes must be deleted before deleting the bucket
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param vectorBucketName - Name of the vector bucket to delete
-  * @returns Promise with empty response on success or error
-  *
-  * @example Delete a vector bucket
-  * ```typescript
-  * const { data, error } = await supabase
-  *   .storage
-  *   .vectors
-  *   .deleteBucket('embeddings-old')
-  * ```
-  */
-  async deleteBucket(vectorBucketName) {
-    return super.deleteBucket(vectorBucketName);
-  }
-};
-var VectorBucketScope = class extends VectorIndexApi {
-  static {
-    __name(this, "VectorBucketScope");
-  }
-  vectorBucketName;
-  /**
-  * @alpha
-  *
-  * Creates a helper that automatically scopes all index operations to the provided bucket.
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @example Creating a vector bucket scope
-  * ```typescript
-  * const bucket = supabase.storage.vectors.from('embeddings-prod')
-  * ```
-  */
-  constructor(url, headers, vectorBucketName, fetch2) {
-    super(url, headers, fetch2);
-    this.vectorBucketName = vectorBucketName;
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Creates a new vector index in this bucket
-  * Convenience method that automatically includes the bucket name
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param options - Index configuration (vectorBucketName is automatically set)
-  * @returns Promise with empty response on success or error
-  *
-  * @example Creating a vector index
-  * ```typescript
-  * const bucket = supabase.storage.vectors.from('embeddings-prod')
-  * await bucket.createIndex({
-  *   indexName: 'documents-openai',
-  *   dataType: 'float32',
-  *   dimension: 1536,
-  *   distanceMetric: 'cosine',
-  *   metadataConfiguration: {
-  *     nonFilterableMetadataKeys: ['raw_text']
-  *   }
-  * })
-  * ```
-  */
-  async createIndex(options) {
-    return super.createIndex({
-      ...options,
-      vectorBucketName: this.vectorBucketName
-    });
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Lists indexes in this bucket
-  * Convenience method that automatically includes the bucket name
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param options - Listing options (vectorBucketName is automatically set)
-  * @returns Promise with response containing indexes array and pagination token or error
-  *
-  * @example List indexes
-  * ```typescript
-  * const bucket = supabase.storage.vectors.from('embeddings-prod')
-  * const { data } = await bucket.listIndexes({ prefix: 'documents-' })
-  * ```
-  */
-  async listIndexes(options = {}) {
-    return super.listIndexes({
-      ...options,
-      vectorBucketName: this.vectorBucketName
-    });
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Retrieves metadata for a specific index in this bucket
-  * Convenience method that automatically includes the bucket name
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param indexName - Name of the index to retrieve
-  * @returns Promise with index metadata or error
-  *
-  * @example Get index metadata
-  * ```typescript
-  * const bucket = supabase.storage.vectors.from('embeddings-prod')
-  * const { data } = await bucket.getIndex('documents-openai')
-  * console.log('Dimension:', data?.index.dimension)
-  * ```
-  */
-  async getIndex(indexName) {
-    return super.getIndex(this.vectorBucketName, indexName);
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Deletes an index from this bucket
-  * Convenience method that automatically includes the bucket name
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param indexName - Name of the index to delete
-  * @returns Promise with empty response on success or error
-  *
-  * @example Delete an index
-  * ```typescript
-  * const bucket = supabase.storage.vectors.from('embeddings-prod')
-  * await bucket.deleteIndex('old-index')
-  * ```
-  */
-  async deleteIndex(indexName) {
-    return super.deleteIndex(this.vectorBucketName, indexName);
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Access operations for a specific index within this bucket
-  * Returns a scoped client for vector data operations
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param indexName - Name of the index
-  * @returns Index-scoped client with vector data operations
-  *
-  * @example Accessing an index
-  * ```typescript
-  * const index = supabase.storage.vectors.from('embeddings-prod').index('documents-openai')
-  *
-  * // Insert vectors
-  * await index.putVectors({
-  *   vectors: [
-  *     { key: 'doc-1', data: { float32: [...] }, metadata: { title: 'Intro' } }
-  *   ]
-  * })
-  *
-  * // Query similar vectors
-  * const { data } = await index.queryVectors({
-  *   queryVector: { float32: [...] },
-  *   topK: 5
-  * })
-  * ```
-  */
-  index(indexName) {
-    return new VectorIndexScope(this.url, this.headers, this.vectorBucketName, indexName, this.fetch);
-  }
-};
-var VectorIndexScope = class extends VectorDataApi {
-  static {
-    __name(this, "VectorIndexScope");
-  }
-  vectorBucketName;
-  indexName;
-  /**
-  *
-  * @alpha
-  *
-  * Creates a helper that automatically scopes all vector operations to the provided bucket/index names.
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @example Creating a vector index scope
-  * ```typescript
-  * const index = supabase.storage.vectors.from('embeddings-prod').index('documents-openai')
-  * ```
-  */
-  constructor(url, headers, vectorBucketName, indexName, fetch2) {
-    super(url, headers, fetch2);
-    this.vectorBucketName = vectorBucketName;
-    this.indexName = indexName;
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Inserts or updates vectors in this index
-  * Convenience method that automatically includes bucket and index names
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param options - Vector insertion options (bucket and index names automatically set)
-  * @returns Promise with empty response on success or error
-  *
-  * @example Insert vectors into an index
-  * ```typescript
-  * const index = supabase.storage.vectors.from('embeddings-prod').index('documents-openai')
-  * await index.putVectors({
-  *   vectors: [
-  *     {
-  *       key: 'doc-1',
-  *       data: { float32: [0.1, 0.2, ...] },
-  *       metadata: { title: 'Introduction', page: 1 }
-  *     }
-  *   ]
-  * })
-  * ```
-  */
-  async putVectors(options) {
-    return super.putVectors({
-      ...options,
-      vectorBucketName: this.vectorBucketName,
-      indexName: this.indexName
-    });
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Retrieves vectors by keys from this index
-  * Convenience method that automatically includes bucket and index names
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param options - Vector retrieval options (bucket and index names automatically set)
-  * @returns Promise with response containing vectors array or error
-  *
-  * @example Get vectors by keys
-  * ```typescript
-  * const index = supabase.storage.vectors.from('embeddings-prod').index('documents-openai')
-  * const { data } = await index.getVectors({
-  *   keys: ['doc-1', 'doc-2'],
-  *   returnMetadata: true
-  * })
-  * ```
-  */
-  async getVectors(options) {
-    return super.getVectors({
-      ...options,
-      vectorBucketName: this.vectorBucketName,
-      indexName: this.indexName
-    });
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Lists vectors in this index with pagination
-  * Convenience method that automatically includes bucket and index names
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param options - Listing options (bucket and index names automatically set)
-  * @returns Promise with response containing vectors array and pagination token or error
-  *
-  * @example List vectors with pagination
-  * ```typescript
-  * const index = supabase.storage.vectors.from('embeddings-prod').index('documents-openai')
-  * const { data } = await index.listVectors({
-  *   maxResults: 500,
-  *   returnMetadata: true
-  * })
-  * ```
-  */
-  async listVectors(options = {}) {
-    return super.listVectors({
-      ...options,
-      vectorBucketName: this.vectorBucketName,
-      indexName: this.indexName
-    });
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Queries for similar vectors in this index
-  * Convenience method that automatically includes bucket and index names
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param options - Query options (bucket and index names automatically set)
-  * @returns Promise with response containing matches array of similar vectors ordered by distance or error
-  *
-  * @example Query similar vectors
-  * ```typescript
-  * const index = supabase.storage.vectors.from('embeddings-prod').index('documents-openai')
-  * const { data } = await index.queryVectors({
-  *   queryVector: { float32: [0.1, 0.2, ...] },
-  *   topK: 5,
-  *   filter: { category: 'technical' },
-  *   returnDistance: true,
-  *   returnMetadata: true
-  * })
-  * ```
-  */
-  async queryVectors(options) {
-    return super.queryVectors({
-      ...options,
-      vectorBucketName: this.vectorBucketName,
-      indexName: this.indexName
-    });
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Deletes vectors by keys from this index
-  * Convenience method that automatically includes bucket and index names
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  * @param options - Deletion options (bucket and index names automatically set)
-  * @returns Promise with empty response on success or error
-  *
-  * @example Delete vectors by keys
-  * ```typescript
-  * const index = supabase.storage.vectors.from('embeddings-prod').index('documents-openai')
-  * await index.deleteVectors({
-  *   keys: ['doc-1', 'doc-2', 'doc-3']
-  * })
-  * ```
-  */
-  async deleteVectors(options) {
-    return super.deleteVectors({
-      ...options,
-      vectorBucketName: this.vectorBucketName,
-      indexName: this.indexName
-    });
-  }
-};
-
-// src/vendor/storage/StorageClient.ts
-var StorageClient = class extends StorageBucketApi {
-  static {
-    __name(this, "StorageClient");
-  }
-  /**
-  * Creates a client for Storage buckets, files, analytics, and vectors.
-  *
-  * @category Storage
-  * @subcategory File Buckets
-  *
-  * @example Using supabase-js (recommended)
-  * ```ts
-  * import { createClient } from '@supabase/supabase-js'
-  *
-  * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
-  * const avatars = supabase.storage.from('avatars')
-  * ```
-  *
-  * @example Standalone import for bundle-sensitive environments
-  * ```ts
-  * import { StorageClient } from '@supabase/storage-js'
-  *
-  * const storage = new StorageClient('https://xyzcompany.supabase.co/storage/v1', {
-  *   apikey: 'your-publishable-key',
-  * })
-  * const avatars = storage.from('avatars')
-  * ```
-  */
-  constructor(url, headers = {}, fetch2, opts) {
-    super(url, headers, fetch2, opts);
-  }
-  /**
-  * Perform file operation in a bucket.
-  *
-  * @category Storage
-  * @subcategory File Buckets
-  *
-  * @param id The bucket id to operate on.
-  *
-  * @example Accessing a bucket
-  * ```typescript
-  * const avatars = supabase.storage.from('avatars')
-  * ```
-  */
-  from(id) {
-    return new StorageFileApi(this.url, this.headers, id, this.fetch);
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Access vector storage operations.
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Vector Buckets
-  *
-  * @returns A StorageVectorsClient instance configured with the current storage settings.
-  */
-  get vectors() {
-    return new StorageVectorsClient(this.url + "/vector", {
-      headers: this.headers,
-      fetch: this.fetch
-    });
-  }
-  /**
-  *
-  * @alpha
-  *
-  * Access analytics storage operations using Iceberg tables.
-  *
-  * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
-  *
-  * @category Storage
-  * @subcategory Analytics Buckets
-  *
-  * @returns A StorageAnalyticsClient instance configured with the current storage settings.
-  */
-  get analytics() {
-    return new StorageAnalyticsClient(this.url + "/iceberg", this.headers, this.fetch);
-  }
-};
-
-// src/modules/storage.ts
-var RUNTIME_STORAGE_BUCKET = "runtime";
-var DEFAULT_SIGNED_URL_TTL_SECONDS = 10 * 60;
-var MAX_SIGNED_URL_TTL_SECONDS = 60 * 60;
-var CloudStoragePathError = class extends Error {
-  static {
-    __name(this, "CloudStoragePathError");
-  }
-  constructor(message) {
-    super(message);
-    this.name = "CloudStoragePathError";
-  }
-};
-var WorkBuddyStorageDownload = class {
-  static {
-    __name(this, "WorkBuddyStorageDownload");
-  }
-  blob;
-  stream;
-  [Symbol.toStringTag] = "WorkBuddyStorageDownload";
-  constructor(blob, stream) {
-    this.blob = blob;
-    this.stream = stream;
-  }
-  asStream() {
-    return this.stream();
+  asStream() {
+    return this.stream();
   }
   then(onfulfilled, onrejected) {
     return this.blob().then(onfulfilled, onrejected);
@@ -9028,7 +7608,9 @@ var WorkBuddyStorageModule = class extends WorkBuddyStorageBucket {
   }
 };
 function createStorageModule(config, fetch2) {
-  const client = new StorageClient(`${config.endpoint}${CLOUD_MODULE_PATHS.storage}`, {}, fetch2);
+  const client = {
+    from: /* @__PURE__ */ __name((bucketID) => new StorageFileApi(`${config.endpoint}${CLOUD_MODULE_PATHS.storage}`, DEFAULT_HEADERS, bucketID, fetch2), "from")
+  };
   return new WorkBuddyStorageModule(client);
 }
 __name(createStorageModule, "createStorageModule");
@@ -9223,6 +7805,8 @@ export {
   anonymousTokenProvider,
   createMemoryStorage,
   createWorkBuddyCloud,
+  getModelCapability,
+  getModelDisplayName,
   shouldClearCredentials
 };
 //# sourceMappingURL=index.js.map