@xylex-group/athena 2.10.0 → 2.12.0

package/dist/cli/index.js

@@ -2000,42 +2000,31 @@ var getSessionCookie = (request2, config) => {
   return null;
 };
 
-// package.json
-var package_default = {
-  version: "2.10.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", "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) {
@@ -2052,13 +2041,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) {
@@ -2068,6 +2064,207 @@ 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 (!hasHeaderIgnoreCase(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.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);
+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 isRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -2194,71 +2391,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);
@@ -2915,19 +3051,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 isRecord4(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 };
@@ -2992,6 +3121,21 @@ function copyDefinedField(target, source, targetKey, sourceKey) {
     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");
@@ -3002,6 +3146,17 @@ function normalizeAdminEmailTemplatePayload(payload) {
   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) {
@@ -3025,6 +3180,17 @@ function normalizeAdminEmailTemplateSendPayload(payload) {
   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) {
@@ -3090,45 +3256,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;
@@ -6254,7 +6382,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;
@@ -6300,9 +6427,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 };
@@ -6374,39 +6498,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 {
@@ -9400,10 +9492,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;
@@ -9534,6 +9622,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,
@@ -9550,18 +9641,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,
@@ -9569,8 +9648,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);
@@ -9628,6 +9713,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,
@@ -9664,48 +9750,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";