@ragable/sdk 0.7.8 → 0.7.10

package/dist/index.mjs

@@ -2335,6 +2335,95 @@ function stripTrailingCommas(text) {
   return text.replace(/,(\s*[}\]])/g, "$1").replace(/,\s*$/, "");
 }
 
+// src/content.ts
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+function toWireUserContent(content) {
+  if (typeof content === "string") return content;
+  const out = [];
+  for (const part of content) {
+    if (!part) continue;
+    if (part.type === "text") {
+      out.push(toWireTextPart(part));
+    } else if (part.type === "image") {
+      out.push(toWireImagePart(part));
+    }
+  }
+  return out;
+}
+function toWireTextPart(part) {
+  return { type: "text", text: part.text };
+}
+function toWireImagePart(part) {
+  const url = imagePartToUrl(part);
+  const detail = part.detail;
+  return {
+    type: "image_url",
+    image_url: detail ? { url, detail } : { url }
+  };
+}
+function imagePartToUrl(part) {
+  const img = part.image;
+  if (img instanceof URL) return img.href;
+  if (typeof img === "string") {
+    if (img.startsWith("http://") || img.startsWith("https://")) return img;
+    if (img.startsWith("data:")) return img;
+    const mediaType = requireMediaType(part, "raw base64 string");
+    assertBase64SizeOk(img);
+    return `data:${mediaType};base64,${img}`;
+  }
+  if (img instanceof Uint8Array || img instanceof ArrayBuffer) {
+    const bytes = img instanceof Uint8Array ? img : new Uint8Array(img);
+    assertBinarySizeOk(bytes);
+    const mediaType = requireMediaType(part, "binary image data");
+    const b64 = bytesToBase64(bytes);
+    return `data:${mediaType};base64,${b64}`;
+  }
+  throw new RagableError(
+    "ImagePart.image must be a string, URL, Uint8Array, or ArrayBuffer",
+    400,
+    { code: "SDK_INVALID_IMAGE_PART" }
+  );
+}
+function requireMediaType(part, what) {
+  const m = part.mediaType?.trim();
+  if (!m) {
+    throw new RagableError(
+      `ImagePart.mediaType is required for ${what} (e.g. "image/png")`,
+      400,
+      { code: "SDK_IMAGE_MEDIA_TYPE_REQUIRED" }
+    );
+  }
+  return m;
+}
+function assertBinarySizeOk(bytes) {
+  if (bytes.byteLength > MAX_IMAGE_BYTES) {
+    throw new RagableError(
+      `Image exceeds 5MB limit (${bytes.byteLength} bytes)`,
+      400,
+      { code: "SDK_IMAGE_TOO_LARGE" }
+    );
+  }
+}
+function assertBase64SizeOk(b64) {
+  const approxBytes = Math.floor(b64.length * 3 / 4);
+  if (approxBytes > MAX_IMAGE_BYTES) {
+    throw new RagableError(
+      `Image exceeds 5MB limit (~${approxBytes} bytes decoded)`,
+      400,
+      { code: "SDK_IMAGE_TOO_LARGE" }
+    );
+  }
+}
+function bytesToBase64(bytes) {
+  const CHUNK = 32768;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    const slice = bytes.subarray(i, i + CHUNK);
+    binary += String.fromCharCode(...slice);
+  }
+  return btoa(binary);
+}
+
 // src/stream-parts.ts
 function normalizeFinishReason(raw) {
   switch (raw) {
@@ -2547,7 +2636,9 @@ var ZERO_USAGE = {
 function buildInferenceRequestBody(params, responseFormat) {
   const body = {
     model: params.model,
-    messages: params.messages
+    messages: params.messages.map(
+      (m) => m.role === "user" ? { role: "user", content: toWireUserContent(m.content) } : m
+    )
   };
   if (params.system !== void 0) body.system = params.system;
   if (typeof params.temperature === "number")
@@ -3782,6 +3873,120 @@ var RagableBrowserStorageClient = class {
     return new BrowserStorageBucketClient(this.options, this.fetchImpl, bucketId);
   }
 };
+var RagableBrowserMailClient = class {
+  constructor(options, auth) {
+    this.options = options;
+    this.auth = auth;
+    __publicField(this, "fetchImpl");
+    this.fetchImpl = bindFetch(options.fetch);
+  }
+  requireWebsiteId() {
+    const websiteId = this.options.websiteId?.trim();
+    if (!websiteId) {
+      throw new RagableError(
+        "websiteId is required for mail operations. Use createWebsiteRagableClient() or pass createBrowserClient({ websiteId, ... }).",
+        400,
+        { code: "SDK_MISSING_WEBSITE_ID" }
+      );
+    }
+    return websiteId;
+  }
+  pathTo(p) {
+    const websiteId = this.requireWebsiteId();
+    const orgId = this.options.organizationId;
+    return `${normalizeBrowserApiBase()}/public/organizations/${orgId}/websites/${websiteId}/mail${p.startsWith("/") ? p : `/${p}`}`;
+  }
+  /**
+   * Get the Bearer token used to authenticate the call:
+   *  1. End-user access token (preferred when an auth group is configured
+   *     and the user has signed in)
+   *  2. `dataStaticKey` from createBrowserClient options
+   *  3. Caller-supplied `getAccessToken()`
+   *
+   * If none is available, throws — server-side use should pass the
+   * data-admin key as `dataStaticKey`.
+   */
+  async getBearerToken() {
+    if (this.auth) {
+      const token = await this.auth.getValidAccessToken().catch(() => null);
+      if (token) return token;
+    }
+    const callerProvided = await this.options.getAccessToken?.();
+    if (typeof callerProvided === "string" && callerProvided.length > 0) {
+      return callerProvided;
+    }
+    if (this.options.dataStaticKey?.trim()) {
+      return this.options.dataStaticKey.trim();
+    }
+    throw new RagableError(
+      "Mail requests need authentication: either sign in via client.auth.signIn(...) or pass dataStaticKey (the auth group data-admin key) when creating the client.",
+      401,
+      { code: "SDK_MAIL_NOT_AUTHENTICATED" }
+    );
+  }
+  async request(path, init = {}) {
+    const token = await this.getBearerToken();
+    const headers = new Headers(init.headers ?? this.options.headers);
+    headers.set("Authorization", `Bearer ${token}`);
+    if (init.body && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    const response = await this.fetchImpl(this.pathTo(path), {
+      ...init,
+      headers
+    });
+    const payload = await parseMaybeJsonBody(response);
+    if (!response.ok) {
+      const message = extractErrorMessage(payload, response.statusText);
+      throw new RagableError(message, response.status, payload);
+    }
+    return payload;
+  }
+  /** Send an email from this website's linked Gmail account. */
+  async send(params) {
+    if (!params.to?.length) {
+      throw new RagableError(
+        "`to` must contain at least one recipient.",
+        400,
+        { code: "SDK_MAIL_NO_RECIPIENTS" }
+      );
+    }
+    if (!params.bodyText && !params.bodyHtml) {
+      throw new RagableError(
+        "Provide at least one of `bodyText` or `bodyHtml`.",
+        400,
+        { code: "SDK_MAIL_NO_BODY" }
+      );
+    }
+    return this.request("/send", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /** Search messages with Gmail query syntax. */
+  async search(params = {}) {
+    const qs = new URLSearchParams();
+    if (params.query) qs.set("q", params.query);
+    if (params.maxResults) qs.set("maxResults", String(params.maxResults));
+    if (params.pageToken) qs.set("pageToken", params.pageToken);
+    if (params.labelIds?.length) qs.set("labelIds", params.labelIds.join(","));
+    const suffix = qs.toString() ? `?${qs.toString()}` : "";
+    return this.request(`/search${suffix}`, { method: "GET" });
+  }
+  /** Fetch a single message in full (headers + decoded text/html body). */
+  async getMessage(messageId) {
+    if (!messageId) {
+      throw new RagableError("`messageId` is required.", 400, {
+        code: "SDK_MAIL_NO_MESSAGE_ID"
+      });
+    }
+    const { message } = await this.request(
+      `/messages/${encodeURIComponent(messageId)}`,
+      { method: "GET" }
+    );
+    return message;
+  }
+};
 var RagableBrowserAgentsClient = class {
   constructor(options) {
     this.options = options;
@@ -4108,6 +4313,7 @@ var RagableBrowser = class {
     __publicField(this, "database");
     __publicField(this, "db");
     __publicField(this, "storage");
+    __publicField(this, "mail");
     __publicField(this, "transport");
     __publicField(this, "_ragableAuth");
     /** Delegates to `database.from()`. Kept for back-compat — prefer `database.from()`. */
@@ -4153,6 +4359,7 @@ var RagableBrowser = class {
     this.database._setTransport(this.transport);
     this.db = this.database;
     this.storage = new RagableBrowserStorageClient(options, bindFetch(options.fetch));
+    this.mail = new RagableBrowserMailClient(options, this._ragableAuth);
   }
   destroy() {
     this._ragableAuth?.destroy();
@@ -4193,6 +4400,7 @@ export {
   RagableBrowserAiClient,
   RagableBrowserAuthClient,
   RagableBrowserDatabaseClient,
+  RagableBrowserMailClient,
   RagableBrowserStorageClient,
   RagableError,
   RagableNetworkError,
@@ -4205,6 +4413,7 @@ export {
   bindFetch,
   buildInferenceRequestBody,
   buildResponseFormat,
+  bytesToBase64,
   collectAssistantTextFromUiSegments,
   collectionRecordToRowWithMeta,
   collectionRecordsToRowWithMeta,
@@ -4220,6 +4429,7 @@ export {
   formatPostgrestError,
   formatSdkError,
   generateIdempotencyKey,
+  imagePartToUrl,
   isIncompleteAgentStreamError,
   mapAgentEvent,
   mapFireworksChunk,
@@ -4234,6 +4444,7 @@ export {
   runAgentChatStreamLenient,
   streamObjectFromContext,
   toRagableResult,
+  toWireUserContent,
   tryParsePartialJson,
   unwrapPostgrest,
   wrapStreamTextAsObject