@xylex-group/athena 2.9.0 → 2.11.0

package/dist/index.cjs

@@ -666,8 +666,8 @@ function deleteSessionCookie(ctx, skipDontRememberMe) {
     expireCookie(ctx, ctx.context.authCookies.dontRememberToken);
   }
 }
-var getSessionCookie = (request, config) => {
-  const cookies = (request instanceof Headers || !("headers" in request) ? request : request.headers).get("cookie");
+var getSessionCookie = (request2, config) => {
+  const cookies = (request2 instanceof Headers || !("headers" in request2) ? request2 : request2.headers).get("cookie");
   if (!cookies) {
     return null;
   }
@@ -687,8 +687,8 @@ var getSessionCookie = (request, config) => {
   }
   return null;
 };
-var getCookieCache = async (request, config) => {
-  const headers = request instanceof Headers || !("headers" in request) ? request : request.headers;
+var getCookieCache = async (request2, config) => {
+  const headers = request2 instanceof Headers || !("headers" in request2) ? request2 : request2.headers;
   const cookieHeader = headers.get("cookie");
   if (!cookieHeader) {
     return null;
@@ -806,7 +806,7 @@ var getCookieCache = async (request, config) => {
 
 // package.json
 var package_default = {
-  version: "2.9.0"
+  version: "2.11.0"
 };
 
 // src/sdk-version.ts
@@ -1858,6 +1858,87 @@ function mergeCallOptions(base, override) {
     }
   };
 }
+function copyDefinedField(target, source, targetKey, sourceKey) {
+  if (!(sourceKey in source)) {
+    return;
+  }
+  const value = source[sourceKey];
+  if (value !== void 0) {
+    target[targetKey] = value;
+  }
+}
+function normalizeEmailTemplateAttachmentsValue(value) {
+  if (typeof value === "string" || value == null) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeEmailTemplateAttachmentsValue(item));
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  const attachment = { ...value };
+  copyDefinedField(attachment, attachment, "file_url", "fileUrl");
+  delete attachment.fileUrl;
+  return attachment;
+}
+function normalizeAdminEmailTemplatePayload(payload) {
+  const normalized = { ...payload };
+  copyDefinedField(normalized, payload, "template_key", "templateKey");
+  copyDefinedField(normalized, payload, "event_type", "eventType");
+  copyDefinedField(normalized, payload, "subject_template", "subjectTemplate");
+  copyDefinedField(normalized, payload, "text_template", "textTemplate");
+  copyDefinedField(normalized, payload, "html_template", "htmlTemplate");
+  copyDefinedField(normalized, payload, "variable_bindings", "variableBindings");
+  copyDefinedField(normalized, payload, "attachment_failure_mode", "attachmentFailureMode");
+  copyDefinedField(normalized, payload, "is_active", "isActive");
+  if (Object.hasOwn(payload, "attachments")) {
+    normalized.attachments = normalizeEmailTemplateAttachmentsValue(payload.attachments);
+  }
+  delete normalized.templateKey;
+  delete normalized.eventType;
+  delete normalized.subjectTemplate;
+  delete normalized.textTemplate;
+  delete normalized.htmlTemplate;
+  delete normalized.variableBindings;
+  delete normalized.attachmentFailureMode;
+  delete normalized.isActive;
+  return normalized;
+}
+function toReactEmailTemplateCompatibilityInput(input) {
+  const payload = input;
+  const compatibility = { ...payload };
+  copyDefinedField(compatibility, payload, "templateKey", "template_key");
+  copyDefinedField(compatibility, payload, "eventType", "event_type");
+  copyDefinedField(compatibility, payload, "subjectTemplate", "subject_template");
+  copyDefinedField(compatibility, payload, "textTemplate", "text_template");
+  copyDefinedField(compatibility, payload, "htmlTemplate", "html_template");
+  copyDefinedField(compatibility, payload, "variableBindings", "variable_bindings");
+  copyDefinedField(compatibility, payload, "attachmentFailureMode", "attachment_failure_mode");
+  copyDefinedField(compatibility, payload, "isActive", "is_active");
+  return compatibility;
+}
+function normalizeAdminEmailTemplateSendPayload(payload) {
+  const normalized = { ...payload };
+  copyDefinedField(normalized, payload, "template_id", "templateId");
+  copyDefinedField(normalized, payload, "recipient_email", "recipientEmail");
+  copyDefinedField(normalized, payload, "render_variables", "renderVariables");
+  copyDefinedField(normalized, payload, "user_id", "userId");
+  copyDefinedField(normalized, payload, "organization_id", "organizationId");
+  copyDefinedField(normalized, payload, "session_token", "sessionToken");
+  copyDefinedField(normalized, payload, "attachment_failure_mode", "attachmentFailureMode");
+  if (Object.hasOwn(payload, "attachments")) {
+    normalized.attachments = normalizeEmailTemplateAttachmentsValue(payload.attachments);
+  }
+  delete normalized.templateId;
+  delete normalized.recipientEmail;
+  delete normalized.renderVariables;
+  delete normalized.userId;
+  delete normalized.organizationId;
+  delete normalized.sessionToken;
+  delete normalized.attachmentFailureMode;
+  return normalized;
+}
 function toSessionGuardFailure(sessionResult) {
   if (sessionResult.status === 401 || sessionResult.data == null) {
     return {
@@ -2164,7 +2245,7 @@ function createAuthClient(config = {}) {
     ...config,
     baseUrl: normalizedBaseUrl
   };
-  const request = (input, options) => {
+  const request2 = (input, options) => {
     const method = input.method ?? (input.body !== void 0 ? "POST" : inferDefaultMethod(input.endpoint));
     const mergedOptions = mergeCallOptions(input.fetchOptions, options);
     return callAuthEndpoint(
@@ -2177,7 +2258,7 @@ function createAuthClient(config = {}) {
   };
   const postGeneric = (endpoint, input, options) => {
     const { payload, fetchOptions } = extractFetchOptions(input);
-    return request(
+    return request2(
       {
         endpoint,
         method: "POST",
@@ -2189,7 +2270,7 @@ function createAuthClient(config = {}) {
   };
   const getGeneric = (endpoint, input, options) => {
     const { fetchOptions } = extractFetchOptions(input);
-    return request(
+    return request2(
       {
         endpoint,
         method: "GET",
@@ -2201,7 +2282,7 @@ function createAuthClient(config = {}) {
   const getWithQuery = (endpoint, input, options) => {
     const { payload, fetchOptions } = extractFetchOptions(input);
     const query = payload?.query;
-    return request(
+    return request2(
       {
         endpoint,
         method: "GET",
@@ -2219,18 +2300,19 @@ function createAuthClient(config = {}) {
     htmlField: "htmlBody",
     textField: "textBody"
   }, withReactEmailRoute(route));
-  const resolveAdminEmailTemplatePayload = (route, input) => resolveReactEmailPayloadFields(input, {
+  const resolveAdminEmailTemplatePayload = (route, input) => resolveReactEmailPayloadFields(toReactEmailTemplateCompatibilityInput(input), {
     htmlField: "htmlTemplate",
     textField: "textTemplate",
     variablesField: "variables"
   }, withReactEmailRoute(route)).then((payload) => {
+    const normalizedPayload = normalizeAdminEmailTemplatePayload(payload);
     if ("variables" in payload && payload.variables !== void 0 && payload.variables !== null) {
       assertAthenaAuthTemplateVariables(
         payload.variables,
         `${route} variables`
       );
     }
-    return payload;
+    return normalizedPayload;
   });
   const requireSession = async (input, options) => {
     const sessionInput = input?.fetchOptions ? { fetchOptions: input.fetchOptions } : void 0;
@@ -2806,7 +2888,15 @@ function createAuthClient(config = {}) {
             await resolveAdminEmailTemplatePayload("/admin/email-template/update", input),
             options
           ),
-          delete: (input, options) => postGeneric("/admin/email-template/delete", input, options)
+          delete: (input, options) => postGeneric("/admin/email-template/delete", input, options),
+          send: (input, options) => postGeneric(
+            "/admin/email-template/send",
+            normalizeAdminEmailTemplateSendPayload(extractFetchOptions(input).payload),
+            options
+          )
+        },
+        eventType: {
+          list: (input, options) => getWithQuery("/admin/email-event-type/list", input, options)
         }
       },
       emailTemplate: {
@@ -2822,7 +2912,15 @@ function createAuthClient(config = {}) {
           "/admin/email-template/update",
           await resolveAdminEmailTemplatePayload("/admin/email-template/update", input),
           options
+        ),
+        send: (input, options) => postGeneric(
+          "/admin/email-template/send",
+          normalizeAdminEmailTemplateSendPayload(extractFetchOptions(input).payload),
+          options
         )
+      },
+      emailEventType: {
+        list: (input, options) => getWithQuery("/admin/email-event-type/list", input, options)
       }
     },
     apiKey: {
@@ -2862,7 +2960,7 @@ function createAuthClient(config = {}) {
           throw new Error("callback.provider requires non-empty code and state values");
         }
         const endpoint = `/callback/${encodeURIComponent(provider)}`;
-        return request({
+        return request2({
           endpoint,
           method: "GET",
           query: {
@@ -2876,7 +2974,7 @@ function createAuthClient(config = {}) {
   };
   return {
     baseUrl: normalizedBaseUrl,
-    request,
+    request: request2,
     signIn: {
       email: (input, options) => executePostWithCompatibleInput(
         resolvedConfig,
@@ -3617,16 +3715,16 @@ function createStorageFileModule(base, config = {}) {
       };
     });
     input.onProgress?.(createProgressSnapshot("preparing", sources, 0, 0, 0));
-    const uploadUrls = uploadRequests.length === 1 ? [await base.createStorageUploadUrl(uploadRequests[0].uploadRequest, options)] : (await base.createStorageUploadUrls({ files: uploadRequests.map((request) => request.uploadRequest) }, options)).files;
+    const uploadUrls = uploadRequests.length === 1 ? [await base.createStorageUploadUrl(uploadRequests[0].uploadRequest, options)] : (await base.createStorageUploadUrls({ files: uploadRequests.map((request2) => request2.uploadRequest) }, options)).files;
     const aggregateLoaded = new Array(uploadRequests.length).fill(0);
     const uploaded = [];
     for (let index = 0; index < uploadRequests.length; index += 1) {
-      const request = uploadRequests[index];
+      const request2 = uploadRequests[index];
       const uploadUrl = uploadUrls[index];
       const response = await putUploadBody(
         uploadUrl.upload.url,
         uploadUrl.upload.headers ?? {},
-        request.source,
+        request2.source,
         input,
         options,
         (progress) => {
@@ -3637,13 +3735,13 @@ function createStorageFileModule(base, config = {}) {
       uploaded.push({
         file: uploadUrl.file,
         upload: uploadUrl.upload,
-        source: request.source.source,
-        fileName: request.source.fileName,
-        storage_key: request.uploadRequest.storage_key,
+        source: request2.source.source,
+        fileName: request2.source.fileName,
+        storage_key: request2.uploadRequest.storage_key,
         response
       });
-      aggregateLoaded[index] = request.source.sizeBytes;
-      input.onProgress?.(createProgressSnapshot("complete", sources, index, request.source.sizeBytes, sum(aggregateLoaded)));
+      aggregateLoaded[index] = request2.source.sizeBytes;
+      input.onProgress?.(createProgressSnapshot("complete", sources, index, request2.source.sizeBytes, sum(aggregateLoaded)));
     }
     return {
       files: uploaded,
@@ -5618,6 +5716,517 @@ function createStorageModule(gateway, runtimeOptions) {
   };
 }
 
+// src/chat/module.ts
+var SDK_NAME3 = "xylex-group/athena-chat";
+var SDK_HEADER_VALUE3 = buildSdkHeaderValue(SDK_NAME3);
+var NO_CACHE_HEADER_VALUE3 = "no-cache";
+var AthenaChatError = class extends Error {
+  status;
+  endpoint;
+  method;
+  requestId;
+  body;
+  constructor(input) {
+    super(input.message);
+    this.name = "AthenaChatError";
+    this.status = input.status;
+    this.endpoint = input.endpoint;
+    this.method = input.method;
+    this.requestId = input.requestId;
+    this.body = input.body;
+  }
+};
+function deriveRealtimeInfoUrl(wsUrl) {
+  if (!wsUrl) {
+    return void 0;
+  }
+  const parsed = new URL(normalizeWsUrl(wsUrl, "Athena chat WebSocket URL"));
+  parsed.protocol = parsed.protocol === "wss:" ? "https:" : "http:";
+  parsed.pathname = parsed.pathname.replace(/\/wss\/gateway$/, "/wss/info");
+  return parsed.toString();
+}
+function normalizeWsUrl(value, label) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`${label} is required.`);
+  }
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    throw new Error(`${label} must be a valid absolute ws(s) URL.`);
+  }
+  if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+    throw new Error(`${label} must use ws or wss.`);
+  }
+  parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+  return parsed.toString().replace(/\/$/, "");
+}
+function isRecord7(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeHeaderValue3(value) {
+  return value ? value : void 0;
+}
+function parseResponseBody4(rawText, contentType) {
+  if (!rawText) {
+    return { parsed: null, parseFailed: false };
+  }
+  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
+  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
+  if (!looksJson) {
+    return { parsed: rawText, parseFailed: false };
+  }
+  try {
+    return { parsed: JSON.parse(rawText), parseFailed: false };
+  } catch {
+    return { parsed: rawText, parseFailed: true };
+  }
+}
+function resolveRequestId3(headers) {
+  return headers.get("x-request-id") ?? headers.get("x-correlation-id") ?? headers.get("x-athena-request-id") ?? void 0;
+}
+function resolveErrorMessage4(payload, fallback) {
+  if (isRecord7(payload)) {
+    for (const candidate of [payload.error, payload.message, payload.details]) {
+      if (typeof candidate === "string" && candidate.trim().length > 0) {
+        return candidate.trim();
+      }
+    }
+  }
+  if (typeof payload === "string" && payload.trim().length > 0) {
+    return payload.trim();
+  }
+  return fallback;
+}
+function encodePathSegment(value, label) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`${label} is required.`);
+  }
+  return encodeURIComponent(normalized);
+}
+function encodeQuery(query) {
+  if (!query) {
+    return "";
+  }
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0 && item !== null) {
+          params.append(key, String(item));
+        }
+      }
+      continue;
+    }
+    params.set(key, String(value));
+  }
+  const encoded = params.toString();
+  return encoded ? `?${encoded}` : "";
+}
+function createSocket(factory, url, protocols) {
+  try {
+    return new factory(url, protocols);
+  } catch (error) {
+    if (error instanceof TypeError) {
+      return factory(url, protocols);
+    }
+    throw error;
+  }
+}
+function buildHeaders3(config, options) {
+  const headers = {
+    Accept: "application/json",
+    apikey: config.apiKey,
+    "x-api-key": config.apiKey,
+    "X-Athena-Sdk": SDK_HEADER_VALUE3
+  };
+  if (config.client || options?.client) {
+    headers["X-Athena-Client"] = options?.client ?? config.client ?? "";
+  }
+  const bearerToken = options?.bearerToken ?? config.bearerToken;
+  if (typeof bearerToken === "string" && bearerToken.trim()) {
+    headers.Authorization = bearerToken.startsWith("Bearer ") ? bearerToken : `Bearer ${bearerToken}`;
+  }
+  const cookie = options?.cookie ?? config.cookie;
+  if (typeof cookie === "string" && cookie.trim()) {
+    headers.Cookie = cookie;
+  }
+  const sessionToken = options?.sessionToken ?? config.sessionToken;
+  if (typeof sessionToken === "string" && sessionToken.trim()) {
+    headers["X-Athena-Auth-Session-Token"] = sessionToken;
+  }
+  if (config.forceNoCache || options?.forceNoCache) {
+    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE3;
+  }
+  for (const source of [config.headers, options?.headers]) {
+    for (const [key, value] of Object.entries(source ?? {})) {
+      const normalized = normalizeHeaderValue3(value);
+      if (normalized) {
+        headers[key] = normalized;
+      }
+    }
+  }
+  return headers;
+}
+function withJsonBody(init, body) {
+  return {
+    ...init,
+    body: body === void 0 ? void 0 : JSON.stringify(body),
+    headers: {
+      "Content-Type": "application/json",
+      ...init.headers
+    }
+  };
+}
+async function request(config, method, endpoint, options, body) {
+  if (!config.baseUrl) {
+    throw new Error(
+      "Athena chat base URL is not configured. Pass createClient({ url }) for unified routing or set chat.url / chatUrl explicitly."
+    );
+  }
+  const url = `${config.baseUrl}${endpoint}`;
+  const init = {
+    method,
+    headers: buildHeaders3(config, options),
+    signal: options?.signal
+  };
+  const finalInit = body === void 0 || method === "GET" ? init : withJsonBody(init, body);
+  const response = await fetch(url, finalInit);
+  const rawText = await response.text();
+  const { parsed } = parseResponseBody4(rawText, response.headers.get("content-type"));
+  if (!response.ok) {
+    throw new AthenaChatError({
+      message: resolveErrorMessage4(parsed, `Athena chat ${method} ${endpoint} failed with ${response.status}`),
+      status: response.status,
+      endpoint,
+      method,
+      requestId: resolveRequestId3(response.headers),
+      body: parsed
+    });
+  }
+  return parsed;
+}
+function unwrapEnvelopeData(payload) {
+  return payload.data;
+}
+function createRealtimeConnection(config, options) {
+  if (!config.wsUrl) {
+    throw new Error(
+      "Athena chat WebSocket URL is not configured. Pass createClient({ url }) for unified routing or set chat.wsUrl / chatWsUrl explicitly."
+    );
+  }
+  const wsFactory = config.webSocketFactory ?? globalThis.WebSocket;
+  if (!wsFactory) {
+    throw new Error(
+      "No WebSocket implementation is available. Provide chat.webSocketFactory in createClient(...) or run in a runtime with global WebSocket support."
+    );
+  }
+  const socket = createSocket(wsFactory, config.wsUrl, options?.protocols);
+  const send = (command) => {
+    socket.send(JSON.stringify(command));
+  };
+  if (options?.onMessage) {
+    const listener = (event) => {
+      const messageEvent = event;
+      const raw = messageEvent?.data;
+      if (typeof raw !== "string") {
+        return;
+      }
+      try {
+        options.onMessage?.(JSON.parse(raw));
+      } catch {
+        options.onMessage?.({ type: "error", error: "Invalid JSON message from Athena chat realtime gateway." });
+      }
+    };
+    if (typeof socket.addEventListener === "function") {
+      socket.addEventListener("message", listener);
+    } else {
+      socket.onmessage = listener;
+    }
+  }
+  const hello = (command) => {
+    send({
+      type: "auth.hello",
+      token: command?.token,
+      room_subscriptions: command?.room_subscriptions
+    });
+  };
+  if (options?.hello) {
+    const onOpen = () => hello({
+      token: options.hello?.token ?? void 0,
+      room_subscriptions: options.hello?.room_subscriptions ?? void 0
+    });
+    if (typeof socket.addEventListener === "function") {
+      socket.addEventListener("open", onOpen);
+    } else {
+      socket.onopen = onOpen;
+    }
+  }
+  return {
+    socket,
+    send,
+    hello,
+    subscribe(roomId, fromSeq) {
+      send({
+        type: "chat.subscribe",
+        room_id: roomId,
+        from_seq: fromSeq ?? void 0
+      });
+    },
+    unsubscribe(roomId) {
+      send({
+        type: "chat.unsubscribe",
+        room_id: roomId
+      });
+    },
+    resume(rooms) {
+      send({
+        type: "chat.resume",
+        rooms
+      });
+    },
+    typingStart(roomId) {
+      send({
+        type: "chat.typing.start",
+        room_id: roomId
+      });
+    },
+    typingStop(roomId) {
+      send({
+        type: "chat.typing.stop",
+        room_id: roomId
+      });
+    },
+    presenceHeartbeat(activeRoomId) {
+      send({
+        type: "chat.presence.heartbeat",
+        active_room_id: activeRoomId ?? void 0
+      });
+    },
+    readUpTo(roomId, input) {
+      send({
+        type: "chat.read.up_to",
+        room_id: roomId,
+        message_id: input?.message_id ?? void 0,
+        seq: input?.seq ?? void 0
+      });
+    },
+    ping(at = (/* @__PURE__ */ new Date()).toISOString()) {
+      send({
+        type: "ping",
+        at
+      });
+    },
+    close(code, reason) {
+      socket.close(code, reason);
+    }
+  };
+}
+function createChatModule(config) {
+  const realtime = {
+    info(options) {
+      const realtimeInfoUrl = config.realtimeInfoUrl ?? deriveRealtimeInfoUrl(config.wsUrl);
+      if (!realtimeInfoUrl) {
+        throw new Error(
+          "Athena chat realtime info URL is not configured. Pass createClient({ url }) for unified routing or set chat.wsUrl / chatWsUrl explicitly."
+        );
+      }
+      return request(
+        {
+          ...config,
+          baseUrl: realtimeInfoUrl
+        },
+        "GET",
+        "",
+        options
+      );
+    },
+    connect(options) {
+      return createRealtimeConnection(config, options);
+    }
+  };
+  return {
+    room: {
+      list(query, options) {
+        return request(
+          config,
+          "GET",
+          `/rooms${encodeQuery(query)}`,
+          options
+        );
+      },
+      create(input, options) {
+        return request(config, "POST", "/rooms", options, input);
+      },
+      get(roomId, options) {
+        return request(
+          config,
+          "GET",
+          `/rooms/${encodePathSegment(roomId, "chat room ID")}`,
+          options
+        );
+      },
+      update(roomId, input, options) {
+        return request(
+          config,
+          "PATCH",
+          `/rooms/${encodePathSegment(roomId, "chat room ID")}`,
+          options,
+          input
+        );
+      },
+      archive(roomId, options) {
+        return request(
+          config,
+          "POST",
+          `/rooms/${encodePathSegment(roomId, "chat room ID")}/archive`,
+          options
+        );
+      },
+      readCursor: {
+        upTo(roomId, input, options) {
+          return request(
+            config,
+            "POST",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/read-cursor`,
+            options,
+            input ?? {}
+          );
+        }
+      },
+      member: {
+        list(roomId, options) {
+          return request(
+            config,
+            "GET",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/members`,
+            options
+          );
+        },
+        add(roomId, input, options) {
+          return request(
+            config,
+            "POST",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/members`,
+            options,
+            input
+          );
+        },
+        remove(roomId, userId, options) {
+          return request(
+            config,
+            "DELETE",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/members/${encodePathSegment(userId, "chat user ID")}`,
+            options
+          );
+        }
+      },
+      message: {
+        list(roomId, query, options) {
+          return request(
+            config,
+            "GET",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/messages${encodeQuery(query)}`,
+            options
+          );
+        },
+        send(roomId, input, options) {
+          return request(
+            config,
+            "POST",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/messages`,
+            options,
+            input
+          );
+        },
+        update(roomId, messageId, input, options) {
+          return request(
+            config,
+            "PATCH",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/messages/${encodePathSegment(messageId, "chat message ID")}`,
+            options,
+            input
+          );
+        },
+        delete(roomId, messageId, options) {
+          return request(
+            config,
+            "DELETE",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/messages/${encodePathSegment(messageId, "chat message ID")}`,
+            options
+          );
+        }
+      }
+    },
+    message: {
+      reaction: {
+        add(messageId, input, options) {
+          return request(
+            config,
+            "POST",
+            `/messages/${encodePathSegment(messageId, "chat message ID")}/reactions`,
+            options,
+            input
+          );
+        },
+        remove(messageId, emoji, options) {
+          return request(
+            config,
+            "DELETE",
+            `/messages/${encodePathSegment(messageId, "chat message ID")}/reactions/${encodePathSegment(emoji, "reaction emoji")}`,
+            options
+          );
+        }
+      },
+      search(input, options) {
+        return request(
+          config,
+          "POST",
+          "/messages/search",
+          options,
+          input
+        );
+      }
+    },
+    realtime
+  };
+}
+var chatSdkManifest = {
+  namespace: "chat",
+  basePath: "/chat",
+  methods: [
+    { name: "listRooms", method: "GET", path: "/chat/rooms" },
+    { name: "createRoom", method: "POST", path: "/chat/rooms" },
+    { name: "getRoom", method: "GET", path: "/chat/rooms/{room_id}" },
+    { name: "updateRoom", method: "PATCH", path: "/chat/rooms/{room_id}" },
+    { name: "archiveRoom", method: "POST", path: "/chat/rooms/{room_id}/archive" },
+    { name: "listRoomMessages", method: "GET", path: "/chat/rooms/{room_id}/messages" },
+    { name: "sendRoomMessage", method: "POST", path: "/chat/rooms/{room_id}/messages" },
+    { name: "updateRoomMessage", method: "PATCH", path: "/chat/rooms/{room_id}/messages/{message_id}" },
+    { name: "deleteRoomMessage", method: "DELETE", path: "/chat/rooms/{room_id}/messages/{message_id}" },
+    { name: "advanceReadCursor", method: "POST", path: "/chat/rooms/{room_id}/read-cursor" },
+    { name: "listRoomMembers", method: "GET", path: "/chat/rooms/{room_id}/members" },
+    { name: "addRoomMembers", method: "POST", path: "/chat/rooms/{room_id}/members" },
+    { name: "removeRoomMember", method: "DELETE", path: "/chat/rooms/{room_id}/members/{user_id}" },
+    { name: "addReaction", method: "POST", path: "/chat/messages/{message_id}/reactions" },
+    { name: "removeReaction", method: "DELETE", path: "/chat/messages/{message_id}/reactions/{emoji}" },
+    { name: "searchMessages", method: "POST", path: "/chat/messages/search" },
+    { name: "getRealtimeInfo", method: "GET", path: "/wss/info" },
+    { name: "connectRealtime", method: "GET", path: "/wss/gateway" }
+  ]
+};
+function unwrapChatRoom(payload) {
+  return unwrapEnvelopeData(payload);
+}
+function unwrapChatMessage(payload) {
+  return unwrapEnvelopeData(payload);
+}
+
 // src/client-builder.ts
 var DEFAULT_BACKEND = { type: "athena" };
 function toBackendConfig(value) {
@@ -5830,7 +6439,7 @@ var BOOLEAN_SAFE_OPERATORS = /* @__PURE__ */ new Set([
   "ilike",
   "is"
 ]);
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isUuidString(value) {
@@ -5843,7 +6452,7 @@ function shouldUseUuidTextComparison(column, value) {
   return typeof value === "string" && isUuidString(value) && isUuidIdentifierColumn(column);
 }
 function isRelationSelectNode(value) {
-  return isRecord7(value) && isRecord7(value.select);
+  return isRecord8(value) && isRecord8(value.select);
 }
 function normalizeIdentifier(value, label) {
   const normalized = value.trim();
@@ -5899,7 +6508,7 @@ function compileRelationToken(key, node) {
   return `${prefix}${relationToken}(${nested})`;
 }
 function compileSelectShape(select) {
-  if (!isRecord7(select)) {
+  if (!isRecord8(select)) {
     throw new Error("findMany select must be an object");
   }
   const tokens = [];
@@ -5923,7 +6532,7 @@ function compileSelectShape(select) {
   return tokens.join(",");
 }
 function selectShapeUsesRelationSchema(select) {
-  if (!isRecord7(select)) {
+  if (!isRecord8(select)) {
     return false;
   }
   for (const rawValue of Object.values(select)) {
@@ -5941,7 +6550,7 @@ function selectShapeUsesRelationSchema(select) {
 }
 function compileColumnWhere(column, input) {
   const normalizedColumn = normalizeIdentifier(column, "where column");
-  if (!isRecord7(input)) {
+  if (!isRecord8(input)) {
     return [buildGatewayCondition("eq", normalizedColumn, input)];
   }
   const conditions = [];
@@ -5969,7 +6578,7 @@ function compileColumnWhere(column, input) {
   return conditions;
 }
 function compileBooleanExpressionTerms(clause, label) {
-  if (!isRecord7(clause)) {
+  if (!isRecord8(clause)) {
     throw new Error(`findMany where.${label} clauses must be objects`);
   }
   const entries = Object.entries(clause).filter(([, value]) => value !== void 0);
@@ -5978,7 +6587,7 @@ function compileBooleanExpressionTerms(clause, label) {
   }
   const [rawColumn, rawValue] = entries[0];
   const column = normalizeIdentifier(rawColumn, `where.${label} column`);
-  if (!isRecord7(rawValue)) {
+  if (!isRecord8(rawValue)) {
     return [`${column}.eq.${stringifyFilterValue(rawValue)}`];
   }
   const operatorEntries = Object.entries(rawValue).filter(([, value]) => value !== void 0);
@@ -6002,7 +6611,7 @@ function compileWhere(where) {
   if (where === void 0) {
     return void 0;
   }
-  if (!isRecord7(where)) {
+  if (!isRecord8(where)) {
     throw new Error("findMany where must be an object");
   }
   const conditions = [];
@@ -6052,7 +6661,7 @@ function compileOrderBy(orderBy) {
   if (orderBy === void 0) {
     return void 0;
   }
-  if (!isRecord7(orderBy)) {
+  if (!isRecord8(orderBy)) {
     throw new Error("findMany orderBy must be an object");
   }
   if ("column" in orderBy) {
@@ -6227,11 +6836,11 @@ function toFindManyAstOrder(order) {
     ascending: order.direction !== "descending"
   };
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function normalizeFindManyAstColumnPredicate(value) {
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     return {
       eq: value
     };
@@ -6255,7 +6864,7 @@ function normalizeFindManyAstBooleanOperand(clause) {
   return normalized;
 }
 function normalizeFindManyAstWhere(where) {
-  if (!where || !isRecord8(where)) {
+  if (!where || !isRecord9(where)) {
     return where;
   }
   const normalized = {};
@@ -6269,7 +6878,7 @@ function normalizeFindManyAstWhere(where) {
       );
       continue;
     }
-    if (key === "not" && isRecord8(value)) {
+    if (key === "not" && isRecord9(value)) {
       normalized.not = normalizeFindManyAstBooleanOperand(
         value
       );
@@ -6280,7 +6889,7 @@ function normalizeFindManyAstWhere(where) {
   return normalized;
 }
 function predicateRequiresUuidQueryFallback(column, value) {
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     return shouldUseUuidTextComparison(column, value);
   }
   const eqValue = value.eq;
@@ -6298,7 +6907,7 @@ function booleanOperandRequiresUuidQueryFallback(clause) {
   return false;
 }
 function findManyAstWhereRequiresLegacyTransport(where) {
-  if (!where || !isRecord8(where)) {
+  if (!where || !isRecord9(where)) {
     return false;
   }
   for (const [key, value] of Object.entries(where)) {
@@ -6313,7 +6922,7 @@ function findManyAstWhereRequiresLegacyTransport(where) {
       }
       continue;
     }
-    if (key === "not" && isRecord8(value)) {
+    if (key === "not" && isRecord9(value)) {
       if (booleanOperandRequiresUuidQueryFallback(value)) {
         return true;
       }
@@ -6862,6 +7471,7 @@ function resolveAthenaModelTargetTableName(target, options = {}) {
 var DEFAULT_COLUMNS = "*";
 var SAFE_CAST_PATTERN = /^[a-z_][a-z0-9_]*(?:\[\])?$/i;
 var ATHENA_NORMALIZED_ERROR_KEY = "__athenaNormalizedError";
+var SDK_NAME4 = "xylex-group/athena";
 function formatResult(response) {
   const result = {
     data: response.data ?? null,
@@ -6938,7 +7548,7 @@ async function executeExperimentalRead(experimental, runner) {
     throw error;
   }
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function firstNonEmptyString2(...values) {
@@ -6950,8 +7560,8 @@ function firstNonEmptyString2(...values) {
   return void 0;
 }
 function resolveStructuredErrorPayload2(raw) {
-  if (!isRecord9(raw)) return null;
-  return isRecord9(raw.error) ? raw.error : raw;
+  if (!isRecord10(raw)) return null;
+  return isRecord10(raw.error) ? raw.error : raw;
 }
 function resolveStructuredErrorDetails(payload, message) {
   if (!payload || !("details" in payload)) {
@@ -6967,7 +7577,7 @@ function resolveStructuredErrorDetails(payload, message) {
   return details;
 }
 function createResultError(response, result, normalized) {
-  const rawRecord = isRecord9(response.raw) ? response.raw : null;
+  const rawRecord = isRecord10(response.raw) ? response.raw : null;
   const payload = resolveStructuredErrorPayload2(response.raw);
   const message = firstNonEmptyString2(
     response.error,
@@ -7030,6 +7640,43 @@ function asAthenaJsonObject(value) {
 function asAthenaJsonObjectArray(values) {
   return values;
 }
+function parseArbitraryResponseBody(rawText, contentType) {
+  if (!rawText) {
+    return null;
+  }
+  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
+  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
+  if (!looksJson) {
+    return rawText;
+  }
+  try {
+    return JSON.parse(rawText);
+  } catch {
+    return rawText;
+  }
+}
+function toRequestQueryString(query) {
+  if (!query) {
+    return "";
+  }
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0 && item !== null) {
+          params.append(key, String(item));
+        }
+      }
+      continue;
+    }
+    params.set(key, String(value));
+  }
+  const encoded = params.toString();
+  return encoded ? `?${encoded}` : "";
+}
 function normalizeSelectColumnsInput(columns) {
   if (columns === void 0) {
     return void 0;
@@ -8336,6 +8983,8 @@ var ATHENA_ENV_GATEWAY_URL_KEYS = [
   "NEXT_PUBLIC_ATHENA_DB_API_URL"
 ];
 var ATHENA_ENV_AUTH_URL_KEYS = ["ATHENA_AUTH_URL", "NEXT_PUBLIC_ATHENA_AUTH_URL"];
+var ATHENA_ENV_CHAT_URL_KEYS = ["ATHENA_CHAT_URL", "NEXT_PUBLIC_ATHENA_CHAT_URL"];
+var ATHENA_ENV_CHAT_WS_URL_KEYS = ["ATHENA_CHAT_WS_URL", "NEXT_PUBLIC_ATHENA_CHAT_WS_URL"];
 var ATHENA_ENV_STORAGE_URL_KEYS = ["ATHENA_STORAGE_URL", "NEXT_PUBLIC_ATHENA_STORAGE_URL"];
 var ATHENA_ENV_KEY_KEYS = [
   "ATHENA_API_KEY",
@@ -8416,6 +9065,15 @@ function appendServicePath(baseUrl, segment) {
   const normalizedBaseUrl = normalizeAthenaGatewayBaseUrl(baseUrl, { label: "Athena public base URL" });
   return `${normalizedBaseUrl}/${segment.replace(/^\/+/, "")}`;
 }
+function appendRealtimeGatewayPath(baseUrl) {
+  const normalizedBaseUrl = normalizeAthenaGatewayBaseUrl(baseUrl, { label: "Athena public base URL" });
+  const wsUrl = new URL(normalizedBaseUrl);
+  wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+  wsUrl.pathname = `${wsUrl.pathname.replace(/\/+$/, "")}/wss/gateway`;
+  wsUrl.search = "";
+  wsUrl.hash = "";
+  return wsUrl.toString();
+}
 function resolveServiceUrlOverride(value, label) {
   return resolveClientServiceBaseUrl(value, label);
 }
@@ -8424,6 +9082,8 @@ function resolveServiceUrls(config) {
   return {
     dbUrl: resolveServiceUrlOverride(config.db?.url, "Athena DB base URL") ?? resolveServiceUrlOverride(config.gateway?.url, "Athena gateway base URL") ?? resolveServiceUrlOverride(config.dbUrl, "Athena DB base URL") ?? resolveServiceUrlOverride(config.gatewayUrl, "Athena gateway base URL") ?? (baseUrl ? appendServicePath(baseUrl, "db") : void 0),
     authUrl: resolveServiceUrlOverride(config.auth?.url, "Athena auth base URL") ?? resolveServiceUrlOverride(config.auth?.baseUrl, "Athena auth base URL") ?? resolveServiceUrlOverride(config.authUrl, "Athena auth base URL") ?? (baseUrl ? appendServicePath(baseUrl, "auth") : void 0),
+    chatUrl: resolveServiceUrlOverride(config.chat?.url, "Athena chat base URL") ?? resolveServiceUrlOverride(config.chatUrl, "Athena chat base URL") ?? (baseUrl ? appendServicePath(baseUrl, "chat") : void 0),
+    chatWsUrl: normalizeOptionalString(config.chat?.wsUrl) ?? normalizeOptionalString(config.chatWsUrl) ?? (baseUrl ? appendRealtimeGatewayPath(baseUrl) : void 0),
     storageUrl: resolveServiceUrlOverride(config.storage?.url, "Athena storage base URL") ?? resolveServiceUrlOverride(config.storageUrl, "Athena storage base URL") ?? (baseUrl ? appendServicePath(baseUrl, "storage") : void 0)
   };
 }
@@ -8516,6 +9176,7 @@ function mergeClientOverrideOptions(base, overrides) {
       } : void 0,
       db: base.db ? { ...base.db } : void 0,
       gateway: base.gateway ? { ...base.gateway } : void 0,
+      chat: base.chat ? { ...base.chat } : void 0,
       storage: base.storage ? { ...base.storage } : void 0
     };
   }
@@ -8526,6 +9187,7 @@ function mergeClientOverrideOptions(base, overrides) {
     auth: mergeAuthClientOptions(base.auth, overrides.auth),
     db: mergeServiceUrlOverrides(base.db, overrides.db),
     gateway: mergeServiceUrlOverrides(base.gateway, overrides.gateway),
+    chat: mergeServiceUrlOverrides(base.chat, overrides.chat),
     storage: mergeServiceUrlOverrides(base.storage, overrides.storage)
   };
 }
@@ -8584,6 +9246,9 @@ function resolveCreateClientConfig(config) {
     headers: config.headers,
     auth: config.auth,
     authUrl: resolvedUrls.authUrl,
+    chat: config.chat,
+    chatUrl: resolvedUrls.chatUrl,
+    chatWsUrl: resolvedUrls.chatWsUrl,
     storageUrl: resolvedUrls.storageUrl,
     experimental: config.experimental
   };
@@ -8668,6 +9333,119 @@ function createClientFromConfig(config, sourceConfig) {
     queryTracer
   );
   const db = createDbModule({ from, rpc, query });
+  const chat = createChatModule({
+    baseUrl: config.chatUrl,
+    apiKey: config.apiKey,
+    client: config.client,
+    headers: config.headers,
+    bearerToken: normalizedAuthConfig?.bearerToken,
+    cookie: normalizedAuthConfig?.cookie,
+    sessionToken: normalizedAuthConfig?.sessionToken,
+    forceNoCache: config.forceNoCache,
+    wsUrl: config.chatWsUrl,
+    webSocketFactory: config.chat?.webSocketFactory ?? void 0
+  });
+  const request2 = async (options) => {
+    const method = options.method ?? "GET";
+    const responseType = options.responseType ?? "json";
+    const service = options.service ?? "db";
+    const baseUrlByService = {
+      db: config.baseUrl,
+      auth: config.authUrl,
+      chat: config.chatUrl,
+      storage: config.storageUrl
+    };
+    const resolvedBaseUrl = options.url ?? baseUrlByService[service];
+    if (!resolvedBaseUrl) {
+      throw new Error(
+        `Athena ${service} base URL is not configured. Pass createClient({ url }) for unified routing or set the service-specific URL first.`
+      );
+    }
+    const normalizedBaseUrl = normalizeAthenaGatewayBaseUrl(resolvedBaseUrl, {
+      label: `Athena ${service} base URL`
+    });
+    const normalizedPath = options.url ? "" : (() => {
+      const path = options.path?.trim();
+      if (!path) {
+        throw new Error("client.request(...) requires either an absolute url or a non-empty path.");
+      }
+      return path.startsWith("/") ? path : `/${path}`;
+    })();
+    const targetUrl = options.url ? `${normalizedBaseUrl}${toRequestQueryString(options.query)}` : `${normalizedBaseUrl}${normalizedPath}${toRequestQueryString(options.query)}`;
+    const headers = {
+      "X-Athena-Sdk": buildSdkHeaderValue(SDK_NAME4),
+      ...config.headers ?? {},
+      ...options.headers ?? {}
+    };
+    if (service !== "auth") {
+      headers.apikey = headers.apikey ?? config.apiKey;
+      headers["x-api-key"] = headers["x-api-key"] ?? config.apiKey;
+      if (config.client && !hasHeaderIgnoreCase(headers, "X-Athena-Client")) {
+        headers["X-Athena-Client"] = config.client;
+      }
+      if (config.userId && !hasHeaderIgnoreCase(headers, "X-User-Id")) {
+        headers["X-User-Id"] = config.userId;
+      }
+      if (config.organizationId && !hasHeaderIgnoreCase(headers, "X-Organization-Id")) {
+        headers["X-Organization-Id"] = config.organizationId;
+      }
+      if (normalizedAuthConfig?.sessionToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Session-Token")) {
+        headers["X-Athena-Auth-Session-Token"] = normalizedAuthConfig.sessionToken;
+      }
+      if (normalizedAuthConfig?.bearerToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Bearer-Token")) {
+        headers["X-Athena-Auth-Bearer-Token"] = normalizedAuthConfig.bearerToken;
+      }
+      if (normalizedAuthConfig?.cookie && !hasHeaderIgnoreCase(headers, "Cookie")) {
+        headers.Cookie = normalizedAuthConfig.cookie;
+      }
+    } else {
+      const authApiKey = normalizedAuthConfig?.apiKey ?? config.apiKey;
+      if (authApiKey && !hasHeaderIgnoreCase(headers, "x-api-key")) {
+        headers.apikey = headers.apikey ?? authApiKey;
+        headers["x-api-key"] = headers["x-api-key"] ?? authApiKey;
+      }
+      if (normalizedAuthConfig?.bearerToken && !hasHeaderIgnoreCase(headers, "Authorization")) {
+        headers.Authorization = `Bearer ${normalizedAuthConfig.bearerToken}`;
+      }
+      if (normalizedAuthConfig?.cookie && !hasHeaderIgnoreCase(headers, "Cookie")) {
+        headers.Cookie = normalizedAuthConfig.cookie;
+      }
+      if (normalizedAuthConfig?.sessionToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Session-Token")) {
+        headers["X-Athena-Auth-Session-Token"] = normalizedAuthConfig.sessionToken;
+      }
+    }
+    const shouldSendJsonBody = options.body !== void 0 && options.body !== null && !(options.body instanceof FormData) && !(options.body instanceof Blob) && !(options.body instanceof URLSearchParams) && !(options.body instanceof ArrayBuffer) && !ArrayBuffer.isView(options.body) && typeof options.body !== "string";
+    if (shouldSendJsonBody && !hasHeaderIgnoreCase(headers, "Content-Type")) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetch(targetUrl, {
+      method,
+      headers,
+      body: options.body === void 0 || options.body === null ? void 0 : shouldSendJsonBody ? JSON.stringify(options.body) : options.body,
+      signal: options.signal,
+      credentials: options.credentials
+    });
+    if (responseType === "response") {
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        data: null,
+        raw: response
+      };
+    }
+    const rawText = await response.text();
+    const parsed = responseType === "text" ? rawText : parseArbitraryResponseBody(rawText, response.headers.get("content-type"));
+    return {
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      data: parsed,
+      raw: response
+    };
+  };
   const withContext = (context) => createClientFromInput(
     mergeClientOverrideOptions(sourceConfig, toClientContextOverrides(context))
   );
@@ -8683,8 +9461,10 @@ function createClientFromConfig(config, sourceConfig) {
     db,
     rpc,
     query,
+    request: request2,
     verifyConnection: gateway.verifyConnection,
     auth: auth.auth,
+    chat,
     withContext,
     withSession,
     withOptions: authWithOptions
@@ -8729,6 +9509,8 @@ var AthenaClient = class {
     const url = options.url ?? readFirstEnvValue(env, ATHENA_ENV_URL_KEYS);
     const gatewayUrl = options.gatewayUrl ?? readFirstEnvValue(env, ATHENA_ENV_GATEWAY_URL_KEYS);
     const authUrl = options.authUrl ?? readFirstEnvValue(env, ATHENA_ENV_AUTH_URL_KEYS);
+    const chatUrl = options.chatUrl ?? readFirstEnvValue(env, ATHENA_ENV_CHAT_URL_KEYS);
+    const chatWsUrl = options.chatWsUrl ?? readFirstEnvValue(env, ATHENA_ENV_CHAT_WS_URL_KEYS);
     const storageUrl = options.storageUrl ?? readFirstEnvValue(env, ATHENA_ENV_STORAGE_URL_KEYS);
     const key = options.key ?? readFirstEnvValue(env, ATHENA_ENV_KEY_KEYS);
     const client = options.client ?? readFirstEnvValue(env, ATHENA_ENV_CLIENT_KEYS);
@@ -8743,6 +9525,8 @@ var AthenaClient = class {
       url,
       gatewayUrl,
       authUrl,
+      chatUrl,
+      chatWsUrl,
       storageUrl,
       key,
       client
@@ -8788,7 +9572,7 @@ function resolveNullishValue(mode) {
   if (mode === "null") return null;
   return "";
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isNullableColumn(model, key) {
@@ -8797,7 +9581,7 @@ function isNullableColumn(model, key) {
 }
 function toModelFormDefaults(model, values, options) {
   const source = values;
-  if (!isRecord10(source)) {
+  if (!isRecord11(source)) {
     return {};
   }
   const mode = options?.nullishMode ?? "empty-string";
@@ -9311,6 +10095,9 @@ var TypedAthenaClientImpl = class _TypedAthenaClientImpl {
   query(query, options) {
     return this.baseClient.query(query, options);
   }
+  request(options) {
+    return this.baseClient.request(options);
+  }
   verifyConnection(options) {
     return this.baseClient.verifyConnection(options);
   }
@@ -11607,15 +12394,15 @@ function readCookieFromHeaders(headers, name) {
   }
   return parseCookies(cookieHeader).get(name);
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function resolveSessionCandidate(value) {
-  if (!isRecord11(value)) {
+  if (!isRecord12(value)) {
     return null;
   }
-  const session = isRecord11(value.session) ? value.session : void 0;
-  const user = isRecord11(value.user) ? value.user : void 0;
+  const session = isRecord12(value.session) ? value.session : void 0;
+  const user = isRecord12(value.user) ? value.user : void 0;
   if (session && typeof session.token === "string" && session.token.length > 0 && user) {
     return {
       session,
@@ -11625,7 +12412,7 @@ function resolveSessionCandidate(value) {
   return null;
 }
 function inferSessionPair(returned) {
-  return resolveSessionCandidate(returned) ?? (isRecord11(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord11(returned) ? resolveSessionCandidate(returned.session) : null);
+  return resolveSessionCandidate(returned) ?? (isRecord12(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord12(returned) ? resolveSessionCandidate(returned.session) : null);
 }
 function resolveResponseHeaders(ctx) {
   if (ctx.context.responseHeaders instanceof Headers) {
@@ -11648,23 +12435,23 @@ function normalizeBasePath(basePath) {
 function isDynamicBaseURLConfig2(baseURL) {
   return typeof baseURL === "object" && baseURL !== null && "allowedHosts" in baseURL && Array.isArray(baseURL.allowedHosts);
 }
-function getRequestUrl(request) {
+function getRequestUrl(request2) {
   try {
-    return new URL(request.url);
+    return new URL(request2.url);
   } catch {
     return new URL("http://localhost");
   }
 }
-function getRequestHost(request, url) {
-  const forwardedHost = request.headers.get("x-forwarded-host")?.split(",")[0]?.trim();
-  const host = forwardedHost || request.headers.get("host") || url.host;
+function getRequestHost(request2, url) {
+  const forwardedHost = request2.headers.get("x-forwarded-host")?.split(",")[0]?.trim();
+  const host = forwardedHost || request2.headers.get("host") || url.host;
   return host || null;
 }
-function getRequestProtocol(request, configuredProtocol, url) {
+function getRequestProtocol(request2, configuredProtocol, url) {
   if (configuredProtocol === "http" || configuredProtocol === "https") {
     return configuredProtocol;
   }
-  const forwardedProto = request.headers.get("x-forwarded-proto")?.split(",")[0]?.trim();
+  const forwardedProto = request2.headers.get("x-forwarded-proto")?.split(",")[0]?.trim();
   if (forwardedProto === "http" || forwardedProto === "https") {
     return forwardedProto;
   }
@@ -11673,12 +12460,12 @@ function getRequestProtocol(request, configuredProtocol, url) {
   }
   return "http";
 }
-function resolveRequestBaseURL(baseURL, request) {
+function resolveRequestBaseURL(baseURL, request2) {
   if (typeof baseURL === "string") {
     return normalizeBaseURL(baseURL);
   }
-  const requestUrl = getRequestUrl(request);
-  const host = getRequestHost(request, requestUrl);
+  const requestUrl = getRequestUrl(request2);
+  const host = getRequestHost(request2, requestUrl);
   if (!host) {
     return null;
   }
@@ -11688,7 +12475,7 @@ function resolveRequestBaseURL(baseURL, request) {
       return null;
     }
   }
-  const protocol = typeof baseURL === "object" && baseURL !== null ? getRequestProtocol(request, baseURL.protocol, requestUrl) : getRequestProtocol(request, void 0, requestUrl);
+  const protocol = typeof baseURL === "object" && baseURL !== null ? getRequestProtocol(request2, baseURL.protocol, requestUrl) : getRequestProtocol(request2, void 0, requestUrl);
   return `${protocol}://${host}`;
 }
 function getOrigin(baseURL) {
@@ -11701,16 +12488,16 @@ function getOrigin(baseURL) {
     return void 0;
   }
 }
-async function resolveTrustedOrigins(config, baseURL, request) {
-  const resolved = typeof config.trustedOrigins === "function" ? await config.trustedOrigins(request) : config.trustedOrigins ?? [];
+async function resolveTrustedOrigins(config, baseURL, request2) {
+  const resolved = typeof config.trustedOrigins === "function" ? await config.trustedOrigins(request2) : config.trustedOrigins ?? [];
   const values = [
     getOrigin(baseURL),
     ...resolved
   ];
   return Array.from(new Set(values.filter((value) => typeof value === "string" && value.length > 0)));
 }
-async function resolveTrustedProviders(config, request) {
-  const configured = typeof config.trustedProviders === "function" ? await config.trustedProviders(request) : config.trustedProviders ?? [];
+async function resolveTrustedProviders(config, request2) {
+  const configured = typeof config.trustedProviders === "function" ? await config.trustedProviders(request2) : config.trustedProviders ?? [];
   const values = [
     ...Object.keys(config.socialProviders ?? {}),
     ...configured
@@ -11835,9 +12622,9 @@ function athenaAuth(config) {
     }
     return ctx;
   };
-  const resolveRequestContext = async (request) => {
-    const requestUrl = getRequestUrl(request);
-    const resolvedBaseURL = resolveRequestBaseURL(config.baseURL, request);
+  const resolveRequestContext = async (request2) => {
+    const requestUrl = getRequestUrl(request2);
+    const resolvedBaseURL = resolveRequestBaseURL(config.baseURL, request2);
     if (!resolvedBaseURL) {
       throw new Error(
         isDynamicBaseURLConfig2(config.baseURL) ? "Could not resolve base URL from request. Check allowedHosts/baseURL." : "Could not resolve base URL from request."
@@ -11848,17 +12635,17 @@ function athenaAuth(config) {
       session: config.session,
       advanced: config.advanced
     });
-    const trustedOrigins = await resolveTrustedOrigins(config, resolvedBaseURL, request);
-    const trustedProviders = await resolveTrustedProviders(config, request);
+    const trustedOrigins = await resolveTrustedOrigins(config, resolvedBaseURL, request2);
+    const trustedProviders = await resolveTrustedProviders(config, request2);
     return {
       auth,
-      request,
+      request: request2,
       url: requestUrl,
       path: requestUrl.pathname,
       basePath: normalizedBasePath,
       baseURL: resolvedBaseURL,
       origin: getOrigin(resolvedBaseURL) ?? resolvedBaseURL,
-      headers: request.headers,
+      headers: request2.headers,
       cookies: requestCookies,
       trustedOrigins,
       trustedProviders,
@@ -11871,8 +12658,8 @@ function athenaAuth(config) {
       socialProviders: auth.socialProviders
     };
   };
-  const handler = async (request) => {
-    const requestContext = await resolveRequestContext(request);
+  const handler = async (request2) => {
+    const requestContext = await resolveRequestContext(request2);
     if (typeof config.handler !== "function") {
       return createJsonResponse(
         {
@@ -11893,7 +12680,7 @@ function athenaAuth(config) {
     const responseHeaders = new Headers(response.headers);
     await runAfterHooks({
       path: requestContext.path,
-      headers: request.headers,
+      headers: request2.headers,
       context: {
         responseHeaders,
         returned: result.returned,
@@ -11975,6 +12762,7 @@ exports.ATHENA_AUTH_MAX_ADMIN_JSON_BYTES = ATHENA_AUTH_MAX_ADMIN_JSON_BYTES;
 exports.ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH = ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH;
 exports.ATHENA_AUTH_MAX_TEMPLATE_VARIABLES = ATHENA_AUTH_MAX_TEMPLATE_VARIABLES;
 exports.ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH = ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH;
+exports.AthenaChatError = AthenaChatError;
 exports.AthenaClient = AthenaClient;
 exports.AthenaError = AthenaError;
 exports.AthenaErrorCategory = AthenaErrorCategory;
@@ -11988,6 +12776,7 @@ exports.DEFAULT_POSTGRES_SCHEMAS = DEFAULT_POSTGRES_SCHEMAS;
 exports.assertInt = assertInt;
 exports.athenaAuth = athenaAuth;
 exports.boolean = boolean;
+exports.chatSdkManifest = chatSdkManifest;
 exports.coerceInt = coerceInt;
 exports.createAthenaStorageError = createAthenaStorageError;
 exports.createAuthClient = createAuthClient;
@@ -12034,6 +12823,8 @@ exports.table = table;
 exports.toModelFormDefaults = toModelFormDefaults;
 exports.toModelPayload = toModelPayload;
 exports.unwrap = unwrap;
+exports.unwrapChatMessage = unwrapChatMessage;
+exports.unwrapChatRoom = unwrapChatRoom;
 exports.unwrapOne = unwrapOne;
 exports.unwrapRows = unwrapRows;
 exports.verifyAthenaGatewayUrl = verifyAthenaGatewayUrl;