@xylex-group/athena 2.11.0 → 2.12.1

package/dist/next/server.js

@@ -158,42 +158,31 @@ var getSessionCookie = (request2, config) => {
   return null;
 };
 
-// package.json
-var package_default = {
-  version: "2.11.0"
-};
-
-// src/sdk-version.ts
-var PACKAGE_VERSION = package_default.version;
-function buildSdkHeaderValue(sdkName) {
-  return `${sdkName} ${PACKAGE_VERSION}`;
-}
-
-// src/gateway/client.ts
-var DEFAULT_CLIENT = "railway_direct";
-var SDK_NAME = "xylex-group/athena";
-var SDK_HEADER_VALUE = buildSdkHeaderValue(SDK_NAME);
+// src/utils/athena-request-headers.ts
 var NO_CACHE_HEADER_VALUE = "no-cache";
-function parseResponseBody(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 };
-  }
-}
+var API_KEY_HEADER_CANDIDATES = ["X-Api-Key", "x-api-key", "apikey"];
+var ATHENA_KEY_HEADER_CANDIDATES = ["X-Athena-Key", "x-athena-key"];
+var SESSION_TOKEN_HEADER_CANDIDATES = ["X-Athena-Auth-Session-Token"];
+var BEARER_MIRROR_HEADER_CANDIDATES = ["X-Athena-Auth-Bearer-Token"];
+var CLIENT_HEADER_CANDIDATES = ["X-Athena-Client", "x-athena-client"];
+var PG_URI_HEADER_CANDIDATES = ["x-pg-uri"];
+var JDBC_URI_HEADER_CANDIDATES = ["x-athena-jdbc-url", "x-jdbc-url"];
+var PROFILE_RULES = {
+  gateway: { apiKeys: true, routing: true, authMirror: true, authBearer: false, contentType: true, stripNullsDefault: true },
+  chat: { apiKeys: true, routing: true, authMirror: true, authBearer: true, accept: true },
+  storage: { apiKeys: true, routing: true, authMirror: true, authBearer: false, contentType: true },
+  auth: { apiKeys: true, routing: false, authMirror: false, authBearer: true, contentType: true },
+  minimal: { apiKeys: false, routing: false, authMirror: false, authBearer: false }
+};
 function normalizeHeaderValue(value) {
   return value ? value : void 0;
 }
-function isCacheControlHeaderName(name) {
-  return name.toLowerCase() === "cache-control";
+function mergeExtraHeaders(configHeaders, callHeaders) {
+  return { ...configHeaders ?? {}, ...callHeaders ?? {} };
+}
+function hasHeaderIgnoreCase(headers, targetKey) {
+  const normalizedTargetKey = targetKey.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === normalizedTargetKey);
 }
 function resolveHeaderValue(headers, candidates) {
   for (const candidate of candidates) {
@@ -210,13 +199,20 @@ function resolveHeaderValue(headers, candidates) {
   }
   return void 0;
 }
+function isCacheControlHeaderName(name) {
+  return name.toLowerCase() === "cache-control";
+}
+function normalizeBearerToken(value) {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^Bearer\s+(.+)$/i);
+  return match?.[1]?.trim() ?? trimmed;
+}
 function resolveBearerTokenFromAuthorizationHeader(headers) {
   const authorization = resolveHeaderValue(headers, ["Authorization"]);
   if (!authorization) {
     return void 0;
   }
-  const match = authorization.match(/^Bearer\s+(.+)$/i);
-  const token = match?.[1]?.trim();
+  const token = normalizeBearerToken(authorization);
   return token ? token : void 0;
 }
 function resolveSessionTokenFromCookieHeader(headers) {
@@ -226,6 +222,210 @@ function resolveSessionTokenFromCookieHeader(headers) {
   }
   return getSessionCookie(new Headers({ cookie })) ?? void 0;
 }
+function resolveBackendType(backend) {
+  if (!backend) {
+    return void 0;
+  }
+  return typeof backend === "string" ? backend : backend.type;
+}
+function resolveRequestHeaderOverrides(config, options, defaults) {
+  return {
+    apiKey: options?.apiKey ?? config.apiKey,
+    athenaKey: options?.athenaKey ?? config.athenaKey,
+    client: options?.client ?? config.client ?? defaults?.client,
+    userId: options?.userId ?? config.userId,
+    organizationId: options?.organizationId ?? config.organizationId,
+    backend: options?.backend ?? config.backend,
+    publishEvent: options?.publishEvent ?? config.publishEvent,
+    stripNulls: options?.stripNulls ?? config.stripNulls ?? defaults?.stripNulls,
+    bearerToken: options?.bearerToken ?? config.bearerToken,
+    cookie: options?.cookie ?? config.cookie,
+    sessionToken: options?.sessionToken ?? config.sessionToken,
+    pgUri: options?.pgUri ?? config.pgUri,
+    jdbcUrl: options?.jdbcUrl ?? config.jdbcUrl,
+    forceNoCache: Boolean(config.forceNoCache || options?.forceNoCache),
+    configHeaders: config.headers,
+    callHeaders: options?.headers
+  };
+}
+function buildServiceRequestHeaders(profile, sdkHeaderValue, config, options, extras) {
+  const rules = PROFILE_RULES[profile];
+  return buildAthenaRequestHeaders({
+    profile,
+    sdkHeaderValue,
+    ...resolveRequestHeaderOverrides(config, options, {
+      client: extras?.client ?? void 0,
+      stripNulls: extras?.stripNulls ?? (rules.stripNullsDefault ? true : void 0)
+    }),
+    contentType: extras?.contentType ?? (rules.contentType ? "application/json" : void 0),
+    accept: extras?.accept ?? (rules.accept ? "application/json" : void 0)
+  });
+}
+function applyAthenaApiKeyHeaders(headers, apiKey, athenaKey) {
+  if (apiKey) {
+    if (!hasHeaderIgnoreCase(headers, "apikey")) {
+      headers.apikey = apiKey;
+    }
+    if (!Object.hasOwn(headers, "x-api-key")) {
+      headers["x-api-key"] = apiKey;
+    }
+    if (!Object.hasOwn(headers, "X-Api-Key")) {
+      headers["X-Api-Key"] = apiKey;
+    }
+  }
+  const resolvedAthenaKey = normalizeHeaderValue(athenaKey) ?? normalizeHeaderValue(apiKey);
+  if (resolvedAthenaKey && !hasHeaderIgnoreCase(headers, "X-Athena-Key")) {
+    headers["X-Athena-Key"] = resolvedAthenaKey;
+  }
+}
+function applyAthenaAuthContextHeaders(headers, input) {
+  const mergedExtraHeaders = mergeExtraHeaders(input.configHeaders, input.callHeaders);
+  const rules = PROFILE_RULES[input.profile];
+  const explicitCookie = normalizeHeaderValue(input.cookie);
+  if (explicitCookie) {
+    mergedExtraHeaders.Cookie = explicitCookie;
+  }
+  const explicitSessionToken = normalizeHeaderValue(input.sessionToken) ?? resolveHeaderValue(mergedExtraHeaders, SESSION_TOKEN_HEADER_CANDIDATES);
+  const derivedSessionToken = explicitSessionToken ?? resolveSessionTokenFromCookieHeader(mergedExtraHeaders);
+  const cookieFromHeaders = resolveHeaderValue(mergedExtraHeaders, ["Cookie"]);
+  if (explicitCookie && !hasHeaderIgnoreCase(headers, "Cookie")) {
+    headers.Cookie = explicitCookie;
+  } else if (cookieFromHeaders && !hasHeaderIgnoreCase(headers, "Cookie")) {
+    headers.Cookie = cookieFromHeaders;
+  }
+  const explicitBearerToken = (() => {
+    const configured = normalizeHeaderValue(input.bearerToken);
+    if (configured) {
+      return normalizeBearerToken(configured);
+    }
+    const mirrored = resolveHeaderValue(mergedExtraHeaders, BEARER_MIRROR_HEADER_CANDIDATES);
+    return mirrored ? normalizeBearerToken(mirrored) : void 0;
+  })();
+  const derivedBearerToken = explicitBearerToken ?? resolveBearerTokenFromAuthorizationHeader(mergedExtraHeaders);
+  if (rules.authBearer && derivedBearerToken && !hasHeaderIgnoreCase(headers, "Authorization")) {
+    headers.Authorization = `Bearer ${derivedBearerToken}`;
+  }
+  if (rules.authMirror) {
+    if (derivedSessionToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Session-Token")) {
+      headers["X-Athena-Auth-Session-Token"] = derivedSessionToken;
+    }
+    if (derivedBearerToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Bearer-Token")) {
+      headers["X-Athena-Auth-Bearer-Token"] = derivedBearerToken;
+    }
+  } else if (derivedSessionToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Session-Token")) {
+    headers["X-Athena-Auth-Session-Token"] = derivedSessionToken;
+  }
+}
+function applyAthenaPgUriHeaders(headers, input) {
+  const mergedExtraHeaders = mergeExtraHeaders(input.configHeaders, input.callHeaders);
+  const pgUri = normalizeHeaderValue(input.pgUri) ?? resolveHeaderValue(mergedExtraHeaders, PG_URI_HEADER_CANDIDATES);
+  if (pgUri && !hasHeaderIgnoreCase(headers, "x-pg-uri")) {
+    headers["x-pg-uri"] = pgUri;
+  }
+  const jdbcUrl = normalizeHeaderValue(input.jdbcUrl) ?? resolveHeaderValue(mergedExtraHeaders, JDBC_URI_HEADER_CANDIDATES);
+  if (jdbcUrl) {
+    if (!hasHeaderIgnoreCase(headers, "x-athena-jdbc-url")) {
+      headers["x-athena-jdbc-url"] = jdbcUrl;
+    }
+    if (!hasHeaderIgnoreCase(headers, "x-jdbc-url")) {
+      headers["x-jdbc-url"] = jdbcUrl;
+    }
+  }
+}
+function buildAthenaRequestHeaders(input) {
+  const forceNoCache = Boolean(input.forceNoCache);
+  const mergedExtraHeaders = mergeExtraHeaders(input.configHeaders, input.callHeaders);
+  const rules = PROFILE_RULES[input.profile];
+  const headerClient = resolveHeaderValue(mergedExtraHeaders, CLIENT_HEADER_CANDIDATES);
+  const finalClient = normalizeHeaderValue(input.client) ?? headerClient;
+  const finalApiKey = normalizeHeaderValue(input.apiKey) ?? resolveHeaderValue(mergedExtraHeaders, API_KEY_HEADER_CANDIDATES);
+  const finalAthenaKey = normalizeHeaderValue(input.athenaKey) ?? resolveHeaderValue(mergedExtraHeaders, ATHENA_KEY_HEADER_CANDIDATES) ?? finalApiKey;
+  const headers = {
+    "X-Athena-Sdk": input.sdkHeaderValue
+  };
+  if (rules.contentType) {
+    headers["Content-Type"] = input.contentType ?? "application/json";
+  }
+  if (input.accept ?? rules.accept) {
+    headers.Accept = input.accept ?? "application/json";
+  }
+  if (rules.routing) {
+    if (normalizeHeaderValue(input.userId)) {
+      headers["X-User-Id"] = input.userId ?? "";
+    }
+    if (normalizeHeaderValue(input.organizationId)) {
+      headers["X-Organization-Id"] = input.organizationId ?? "";
+    }
+    if (finalClient) {
+      headers["X-Athena-Client"] = finalClient;
+    }
+    const backendType = resolveBackendType(input.backend);
+    if (backendType) {
+      headers["X-Backend-Type"] = backendType;
+    }
+    if (typeof input.stripNulls === "boolean") {
+      headers["X-Strip-Nulls"] = input.stripNulls ? "true" : "false";
+    } else if (rules.stripNullsDefault) {
+      headers["X-Strip-Nulls"] = "true";
+    }
+    if (normalizeHeaderValue(input.publishEvent)) {
+      headers["X-Publish-Event"] = input.publishEvent ?? "";
+    }
+  }
+  if (rules.apiKeys && (finalApiKey || finalAthenaKey)) {
+    applyAthenaApiKeyHeaders(headers, finalApiKey, finalAthenaKey);
+  }
+  applyAthenaAuthContextHeaders(headers, input);
+  applyAthenaPgUriHeaders(headers, input);
+  const reservedClientHeaderKeys = new Set(CLIENT_HEADER_CANDIDATES.map((key) => key.toLowerCase()));
+  Object.entries(mergedExtraHeaders).forEach(([key, value]) => {
+    if (reservedClientHeaderKeys.has(key.toLowerCase())) {
+      return;
+    }
+    if (forceNoCache && isCacheControlHeaderName(key)) {
+      return;
+    }
+    const normalized = normalizeHeaderValue(value);
+    if (normalized) {
+      headers[key] = normalized;
+    }
+  });
+  if (forceNoCache) {
+    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE;
+  }
+  return headers;
+}
+
+// package.json
+var package_default = {
+  version: "2.12.1"
+};
+
+// src/sdk-version.ts
+var PACKAGE_VERSION = package_default.version;
+function buildSdkHeaderValue(sdkName) {
+  return `${sdkName} ${PACKAGE_VERSION}`;
+}
+
+// src/gateway/client.ts
+var DEFAULT_CLIENT = "railway_direct";
+var SDK_NAME = "xylex-group/athena";
+var SDK_HEADER_VALUE = buildSdkHeaderValue(SDK_NAME);
+function parseResponseBody(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 isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -352,71 +552,10 @@ function buildRpcGetEndpoint(payload) {
   return withQuery;
 }
 function buildHeaders(config, options) {
-  const mergedStripNulls = options?.stripNulls ?? true;
-  const forceNoCache = Boolean(config.forceNoCache || options?.forceNoCache);
-  const extraHeaders = {
-    ...config.headers ?? {},
-    ...options?.headers ?? {}
-  };
-  const headerClient = extraHeaders["x-athena-client"] ?? extraHeaders["X-Athena-Client"];
-  const finalClient = options?.client ?? config.client ?? (typeof headerClient === "string" ? headerClient : void 0) ?? DEFAULT_CLIENT;
-  const finalApiKey = options?.apiKey ?? config.apiKey;
-  const finalPublishEvent = options?.publishEvent ?? config.publishEvent;
-  const headers = {
-    "Content-Type": "application/json",
-    "X-Athena-Sdk": SDK_HEADER_VALUE
-  };
-  if (options?.userId ?? config.userId) {
-    headers["X-User-Id"] = options?.userId ?? config.userId ?? "";
-  }
-  if (options?.organizationId ?? config.organizationId) {
-    headers["X-Organization-Id"] = options?.organizationId ?? config.organizationId ?? "";
-  }
-  if (finalClient) {
-    headers["X-Athena-Client"] = finalClient;
-  }
-  const finalBackend = options?.backend ?? config.backend;
-  if (finalBackend) {
-    const type = typeof finalBackend === "string" ? finalBackend : finalBackend.type;
-    if (type) headers["X-Backend-Type"] = type;
-  }
-  if (typeof mergedStripNulls === "boolean") {
-    headers["X-Strip-Nulls"] = mergedStripNulls ? "true" : "false";
-  }
-  if (finalPublishEvent) {
-    headers["X-Publish-Event"] = finalPublishEvent;
-  }
-  if (finalApiKey) {
-    headers["apikey"] = finalApiKey;
-    headers["x-api-key"] = headers["x-api-key"] ?? finalApiKey;
-  }
-  const explicitSessionToken = resolveHeaderValue(extraHeaders, [
-    "X-Athena-Auth-Session-Token"
-  ]);
-  const derivedSessionToken = explicitSessionToken ?? resolveSessionTokenFromCookieHeader(extraHeaders);
-  if (derivedSessionToken) {
-    headers["X-Athena-Auth-Session-Token"] = derivedSessionToken;
-  }
-  const explicitBearerToken = resolveHeaderValue(extraHeaders, [
-    "X-Athena-Auth-Bearer-Token"
-  ]);
-  const derivedBearerToken = explicitBearerToken ?? resolveBearerTokenFromAuthorizationHeader(extraHeaders);
-  if (derivedBearerToken) {
-    headers["X-Athena-Auth-Bearer-Token"] = derivedBearerToken;
-  }
-  const athenaClientKeys = ["x-athena-client", "X-Athena-Client"];
-  Object.entries(extraHeaders).forEach(([key, value]) => {
-    if (athenaClientKeys.includes(key)) return;
-    if (forceNoCache && isCacheControlHeaderName(key)) return;
-    const normalized = normalizeHeaderValue(value);
-    if (normalized) {
-      headers[key] = normalized;
-    }
+  return buildServiceRequestHeaders("gateway", SDK_HEADER_VALUE, config, options, {
+    client: options?.client ?? config.client ?? DEFAULT_CLIENT,
+    stripNulls: options?.stripNulls ?? true
   });
-  if (forceNoCache) {
-    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE;
-  }
-  return headers;
 }
 function toInvalidUrlResponse(error, endpoint, method) {
   const message = error instanceof Error ? error.message : String(error);
@@ -1073,19 +1212,12 @@ async function resolveReactEmailPayloadFields(input, fields, options) {
 var DEFAULT_AUTH_BASE_URL = "http://localhost:3001/api/auth";
 var SDK_NAME2 = "xylex-group/athena-auth";
 var SDK_HEADER_VALUE2 = buildSdkHeaderValue(SDK_NAME2);
-var NO_CACHE_HEADER_VALUE2 = "no-cache";
 function normalizeBaseUrl(baseUrl) {
   return (baseUrl ?? DEFAULT_AUTH_BASE_URL).replace(/\/$/, "");
 }
 function isRecord3(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function normalizeHeaderValue2(value) {
-  return value ? value : void 0;
-}
-function isCacheControlHeaderName2(name) {
-  return name.toLowerCase() === "cache-control";
-}
 function parseResponseBody2(rawText, contentType) {
   if (!rawText) {
     return { parsed: null, parseFailed: false };
@@ -1285,45 +1417,7 @@ function extractFetchOptions(input) {
   };
 }
 function buildHeaders2(config, options) {
-  const forceNoCache = Boolean(config.forceNoCache || options?.forceNoCache);
-  const headers = {
-    "Content-Type": "application/json",
-    "X-Athena-Sdk": SDK_HEADER_VALUE2
-  };
-  const apiKey = options?.apiKey ?? config.apiKey;
-  if (apiKey) {
-    headers.apikey = apiKey;
-    headers["x-api-key"] = apiKey;
-  }
-  const bearerToken = options?.bearerToken ?? config.bearerToken;
-  if (bearerToken) {
-    headers.Authorization = `Bearer ${bearerToken}`;
-  }
-  const cookie = options?.cookie ?? config.cookie;
-  if (cookie) {
-    headers.Cookie = cookie;
-  }
-  const sessionToken = options?.sessionToken ?? config.sessionToken;
-  if (sessionToken) {
-    headers["X-Athena-Auth-Session-Token"] = sessionToken;
-  }
-  const mergedExtraHeaders = {
-    ...config.headers ?? {},
-    ...options?.headers ?? {}
-  };
-  Object.entries(mergedExtraHeaders).forEach(([key, value]) => {
-    if (forceNoCache && isCacheControlHeaderName2(key)) {
-      return;
-    }
-    const normalized = normalizeHeaderValue2(value);
-    if (normalized) {
-      headers[key] = normalized;
-    }
-  });
-  if (forceNoCache) {
-    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE2;
-  }
-  return headers;
+  return buildServiceRequestHeaders("auth", SDK_HEADER_VALUE2, config, options);
 }
 function appendQueryParam(searchParams, key, value) {
   if (value === void 0 || value === null) return;
@@ -4785,7 +4879,6 @@ 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;
@@ -4831,9 +4924,6 @@ function normalizeWsUrl(value, label) {
 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 };
@@ -4905,39 +4995,7 @@ function createSocket(factory, url, protocols) {
   }
 }
 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;
+  return buildServiceRequestHeaders("chat", SDK_HEADER_VALUE3, config, options);
 }
 function withJsonBody(init, body) {
   return {
@@ -5316,6 +5374,9 @@ var AthenaClientBuilderImpl = class {
   defaultOrganizationId;
   forceNoCacheEnabled = false;
   defaultHeaders;
+  pgUriValue;
+  jdbcUrlValue;
+  athenaKeyValue;
   authConfig;
   dbUrlOverride;
   gatewayUrlOverride;
@@ -5342,6 +5403,18 @@ var AthenaClientBuilderImpl = class {
     this.defaultHeaders = headers;
     return this;
   }
+  pgUri(pgUri) {
+    this.pgUriValue = pgUri;
+    return this;
+  }
+  jdbcUrl(jdbcUrl) {
+    this.jdbcUrlValue = jdbcUrl;
+    return this;
+  }
+  athenaKey(athenaKey) {
+    this.athenaKeyValue = athenaKey;
+    return this;
+  }
   auth(config) {
     this.authConfig = mergeAuthClientConfig(this.authConfig, config);
     return this;
@@ -5378,6 +5451,15 @@ var AthenaClientBuilderImpl = class {
     if (options.headers !== void 0) {
       this.defaultHeaders = mergeHeaders(this.defaultHeaders, options.headers);
     }
+    if (options.pgUri !== void 0) {
+      this.pgUriValue = options.pgUri;
+    }
+    if (options.jdbcUrl !== void 0) {
+      this.jdbcUrlValue = options.jdbcUrl;
+    }
+    if (options.athenaKey !== void 0) {
+      this.athenaKeyValue = options.athenaKey;
+    }
     if (options.auth !== void 0) {
       this.authConfig = mergeAuthClientConfig(this.authConfig, options.auth);
     }
@@ -5429,6 +5511,9 @@ var AthenaClientBuilderImpl = class {
       userId: this.defaultUserId,
       organizationId: this.defaultOrganizationId,
       forceNoCache: this.forceNoCacheEnabled,
+      pgUri: this.pgUriValue,
+      jdbcUrl: this.jdbcUrlValue,
+      athenaKey: this.athenaKeyValue,
       backend: this.backendConfig,
       headers: this.defaultHeaders,
       db: this.dbUrlOverride ? { url: this.dbUrlOverride } : void 0,
@@ -8135,10 +8220,6 @@ function resolveRequiredClientApiKey(value) {
   }
   return normalizedValue;
 }
-function hasHeaderIgnoreCase(headers, targetKey) {
-  const normalizedTargetKey = targetKey.toLowerCase();
-  return Object.keys(headers).some((key) => key.toLowerCase() === normalizedTargetKey);
-}
 function mergeClientHeaders(current, next) {
   if (!current && !next) {
     return void 0;
@@ -8269,6 +8350,9 @@ function resolveCreateClientConfig(config) {
     userId: config.userId,
     organizationId: config.organizationId,
     forceNoCache: config.forceNoCache,
+    pgUri: config.pgUri,
+    jdbcUrl: config.jdbcUrl,
+    athenaKey: config.athenaKey,
     backend: toBackendConfig(config.backend),
     headers: config.headers,
     auth: config.auth,
@@ -8285,18 +8369,6 @@ function createClientFromInput(sourceConfig) {
 }
 function createClientFromConfig(config, sourceConfig) {
   const normalizedAuthConfig = normalizeAuthClientConfig(config.auth, config.authUrl);
-  const gatewayHeaders = {
-    ...config.headers ?? {}
-  };
-  if (normalizedAuthConfig?.bearerToken && !hasHeaderIgnoreCase(gatewayHeaders, "X-Athena-Auth-Bearer-Token")) {
-    gatewayHeaders["X-Athena-Auth-Bearer-Token"] = normalizedAuthConfig.bearerToken;
-  }
-  if (normalizedAuthConfig?.cookie && !hasHeaderIgnoreCase(gatewayHeaders, "Cookie")) {
-    gatewayHeaders.Cookie = normalizedAuthConfig.cookie;
-  }
-  if (normalizedAuthConfig?.sessionToken && !hasHeaderIgnoreCase(gatewayHeaders, "X-Athena-Auth-Session-Token")) {
-    gatewayHeaders["X-Athena-Auth-Session-Token"] = normalizedAuthConfig.sessionToken;
-  }
   const gateway = createAthenaGatewayClient({
     baseUrl: config.baseUrl,
     apiKey: config.apiKey,
@@ -8304,8 +8376,14 @@ function createClientFromConfig(config, sourceConfig) {
     userId: config.userId,
     organizationId: config.organizationId,
     forceNoCache: config.forceNoCache,
+    pgUri: config.pgUri,
+    jdbcUrl: config.jdbcUrl,
+    athenaKey: config.athenaKey,
     backend: config.backend,
-    headers: gatewayHeaders
+    bearerToken: normalizedAuthConfig?.bearerToken,
+    cookie: normalizedAuthConfig?.cookie,
+    sessionToken: normalizedAuthConfig?.sessionToken,
+    headers: config.headers
   });
   const formatGatewayResult = createResultFormatter(config.experimental);
   const queryTracer = createQueryTracer(config.experimental);
@@ -8363,6 +8441,7 @@ function createClientFromConfig(config, sourceConfig) {
   const chat = createChatModule({
     baseUrl: config.chatUrl,
     apiKey: config.apiKey,
+    athenaKey: config.athenaKey,
     client: config.client,
     headers: config.headers,
     bearerToken: normalizedAuthConfig?.bearerToken,
@@ -8399,48 +8478,28 @@ function createClientFromConfig(config, sourceConfig) {
       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 requestProfile = service === "auth" ? "auth" : service === "chat" ? "chat" : service === "storage" ? "storage" : "gateway";
+    const headers = buildAthenaRequestHeaders({
+      profile: requestProfile,
+      sdkHeaderValue: buildSdkHeaderValue(SDK_NAME4),
+      apiKey: options.apiKey ?? (service === "auth" ? normalizedAuthConfig?.apiKey ?? config.apiKey : config.apiKey),
+      athenaKey: options.athenaKey ?? config.athenaKey,
+      client: config.client,
+      userId: config.userId,
+      organizationId: config.organizationId,
+      backend: config.backend,
+      pgUri: config.pgUri,
+      jdbcUrl: config.jdbcUrl,
+      bearerToken: normalizedAuthConfig?.bearerToken,
+      cookie: normalizedAuthConfig?.cookie,
+      sessionToken: normalizedAuthConfig?.sessionToken,
+      forceNoCache: config.forceNoCache,
+      configHeaders: config.headers,
+      callHeaders: options.headers,
+      accept: service === "chat" ? "application/json" : void 0,
+      contentType: service === "auth" || service === "db" || service === "storage" ? "application/json" : void 0,
+      stripNulls: service === "db" ? true : void 0
+    });
     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";