@sagepilot-ai/react-native-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1441 @@
+// src/core/errors/SagepilotChatError.ts
+var SagepilotChatError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = "SagepilotChatError";
+    this.code = code;
+    this.status = options.status;
+    this.requestId = options.requestId;
+    this.details = options.details;
+    if (options.cause) {
+      this.cause = options.cause;
+    }
+  }
+};
+
+// src/core/config/constants.ts
+var SDK_NAME = "@sagepilot-ai/react-native-sdk";
+var SDK_VERSION = "0.1.0";
+var DEFAULT_HOST = "https://app.sagepilot.ai";
+var DEFAULT_WIDGET_HOST = "https://app.sagepilot.ai";
+var CUSTOMER_API_PREFIX = "/customer-api/v1";
+var DEFAULT_UNREAD_POLL_INTERVAL_MS = 3e4;
+var DEFAULT_HOSTED_CLAIMS_STORAGE_KEY_PREFIX = "sg_chat_claims";
+
+// src/core/auth/sessionManager.ts
+var SagepilotSessionManager = class {
+  constructor(tokenManager) {
+    this.tokenManager = tokenManager;
+    this.currentSession = null;
+  }
+  async hydrate() {
+    this.currentSession = await this.tokenManager.getSession();
+    return this.currentSession;
+  }
+  getSession() {
+    return this.currentSession;
+  }
+  requireSession() {
+    if (!this.currentSession?.session_id || !this.currentSession.session_token) {
+      throw new SagepilotChatError(
+        "not_initialized",
+        `${SDK_NAME} does not have an active customer session. Call configure() first.`
+      );
+    }
+    return this.currentSession;
+  }
+  async setSession(session) {
+    this.currentSession = {
+      session_id: session.session_id,
+      session_token: session.session_token,
+      customer_id: session.customer_id ?? null,
+      conversation_id: session.conversation_id ?? null,
+      authenticated: session.authenticated ?? false,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.tokenManager.setSession(this.currentSession);
+    return this.currentSession;
+  }
+  async updateSession(updates) {
+    const session = this.requireSession();
+    return this.setSession({
+      ...session,
+      ...updates
+    });
+  }
+  async clearSession() {
+    this.currentSession = null;
+    await this.tokenManager.clearSession();
+  }
+  getAuthorizationHeader(sessionToken = this.requireSession().session_token) {
+    return this.tokenManager.createAuthorizationHeader(sessionToken);
+  }
+};
+
+// src/core/storage/tokenStorage.ts
+function createMemoryTokenStorage() {
+  const records = /* @__PURE__ */ new Map();
+  return {
+    async getItem(key) {
+      return records.get(key) ?? null;
+    },
+    async setItem(key, value) {
+      records.set(key, value);
+    },
+    async removeItem(key) {
+      records.delete(key);
+    }
+  };
+}
+function createKeychainTokenStorage(keychain, options = {}) {
+  return {
+    async getItem(key) {
+      const result = await keychain.getGenericPassword({
+        ...options,
+        service: key
+      });
+      return result ? result.password : null;
+    },
+    async setItem(key, value) {
+      await keychain.setGenericPassword("sagepilot", value, {
+        ...options,
+        service: key
+      });
+    },
+    async removeItem(key) {
+      await keychain.resetGenericPassword({
+        ...options,
+        service: key
+      });
+    }
+  };
+}
+function serializeSessionTokenRecord(record) {
+  return JSON.stringify(record);
+}
+function parseSessionTokenRecord(value) {
+  if (!value) return null;
+  try {
+    const record = JSON.parse(value);
+    if (!record.session_id || !record.session_token) return null;
+    return {
+      session_id: record.session_id,
+      session_token: record.session_token,
+      customer_id: record.customer_id ?? null,
+      conversation_id: record.conversation_id ?? null,
+      authenticated: record.authenticated ?? false,
+      updated_at: record.updated_at
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/core/auth/tokenManager.ts
+function getSessionStorageKey(channelId) {
+  return `sagepilot_rn_session_${channelId}`;
+}
+var SagepilotTokenManager = class {
+  constructor(channelId, storage) {
+    this.channelId = channelId;
+    this.storage = storage;
+  }
+  async getSession() {
+    return parseSessionTokenRecord(await this.storage.getItem(getSessionStorageKey(this.channelId)));
+  }
+  async setSession(session) {
+    await this.storage.setItem(
+      getSessionStorageKey(this.channelId),
+      serializeSessionTokenRecord({
+        session_id: session.session_id,
+        session_token: session.session_token,
+        customer_id: session.customer_id ?? null,
+        conversation_id: session.conversation_id ?? null,
+        authenticated: session.authenticated ?? false,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+  async clearSession() {
+    await this.storage.removeItem(getSessionStorageKey(this.channelId));
+  }
+  createAuthorizationHeader(sessionToken) {
+    return {
+      Authorization: `Bearer ${sessionToken}`
+    };
+  }
+};
+
+// src/core/config/resolveConfig.ts
+function normalizeHost(host = DEFAULT_HOST) {
+  return host.replace(/\/+$/, "");
+}
+function readRuntimeEnv(name) {
+  return globalThis.process?.env?.[name]?.trim();
+}
+function resolveSagepilotHost(configuredHost) {
+  const envHost = readRuntimeEnv("EXPO_PUBLIC_SAGEPILOT_HOST") || readRuntimeEnv("SAGEPILOT_HOST") || readRuntimeEnv("EXPO_PUBLIC_SAGEPILOT_CUSTOMER_API_BASE_URL") || readRuntimeEnv("SAGEPILOT_CUSTOMER_API_BASE_URL");
+  return normalizeHost(configuredHost || envHost);
+}
+function resolveCustomerApiHost(configuredApiHost, fallbackHost) {
+  const envHost = readRuntimeEnv("EXPO_PUBLIC_SAGEPILOT_CUSTOMER_API_BASE_URL") || readRuntimeEnv("SAGEPILOT_CUSTOMER_API_BASE_URL");
+  return normalizeHost(configuredApiHost || envHost || fallbackHost);
+}
+function parseKey(key) {
+  const [workspaceId, channelId] = key.split(":");
+  if (!workspaceId || !channelId) {
+    throw new SagepilotChatError(
+      "invalid_config",
+      `${SDK_NAME} Invalid key format. Expected "workspace_id:channel_id".`
+    );
+  }
+  return { workspaceId, channelId };
+}
+function resolveFetch(fetchImpl) {
+  const resolvedFetch = fetchImpl ?? globalThis.fetch;
+  if (typeof resolvedFetch !== "function") {
+    throw new SagepilotChatError(
+      "invalid_config",
+      `${SDK_NAME} requires a fetch implementation in this runtime.`
+    );
+  }
+  return resolvedFetch.bind(globalThis);
+}
+
+// src/core/http/retryPolicy.ts
+var DEFAULT_RETRY_POLICY = {
+  retries: 2,
+  baseDelayMs: 250,
+  maxDelayMs: 2e3,
+  retryOnStatuses: [408, 425, 429, 500, 502, 503, 504]
+};
+function resolveRetryPolicy(policy) {
+  return {
+    retries: policy?.retries ?? DEFAULT_RETRY_POLICY.retries,
+    baseDelayMs: policy?.baseDelayMs ?? DEFAULT_RETRY_POLICY.baseDelayMs,
+    maxDelayMs: policy?.maxDelayMs ?? DEFAULT_RETRY_POLICY.maxDelayMs,
+    retryOnStatuses: policy?.retryOnStatuses ?? DEFAULT_RETRY_POLICY.retryOnStatuses
+  };
+}
+function shouldRetryStatus(status, policy) {
+  return policy.retryOnStatuses.includes(status);
+}
+function getRetryDelayMs(attempt, policy) {
+  const exponentialDelay = policy.baseDelayMs * 2 ** Math.max(attempt - 1, 0);
+  return Math.min(exponentialDelay, policy.maxDelayMs);
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/http/client.ts
+var RETRYABLE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+async function readResponseJson(response) {
+  if (response.status === 204 || response.status === 205) {
+    return void 0;
+  }
+  try {
+    const text = await response.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  } catch (error) {
+    throw new SagepilotChatError(
+      "invalid_response",
+      `${SDK_NAME} API returned invalid JSON.`,
+      { status: response.status, cause: error }
+    );
+  }
+}
+function normalizeErrorCode(code) {
+  return code || "invalid_response";
+}
+function toHeaders(headers) {
+  return new Headers(headers);
+}
+function mergeHeaders(baseHeaders, requestHeaders) {
+  const headers = toHeaders(baseHeaders);
+  const extraHeaders = toHeaders(requestHeaders);
+  extraHeaders.forEach((value, key) => {
+    headers.set(key, value);
+  });
+  return headers;
+}
+function withJsonHeaders(baseHeaders, requestHeaders) {
+  const headers = mergeHeaders(baseHeaders, requestHeaders);
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
+  return headers;
+}
+var SagepilotHttpClient = class {
+  constructor(options) {
+    this.fetchImpl = options.fetch;
+    this.baseHeaders = options.headers;
+    this.retryPolicy = resolveRetryPolicy(options.retryPolicy);
+  }
+  async request(url, init) {
+    const policy = resolveRetryPolicy(init.retryPolicy ?? this.retryPolicy);
+    const method = (init.method ?? "GET").toUpperCase();
+    const canRetry = RETRYABLE_METHODS.has(method);
+    let lastNetworkError;
+    for (let attempt = 0; attempt <= policy.retries; attempt += 1) {
+      let response;
+      try {
+        response = await this.fetchImpl(url, {
+          ...init,
+          headers: mergeHeaders(this.baseHeaders, init.headers)
+        });
+      } catch (error) {
+        lastNetworkError = error;
+        if (canRetry && attempt < policy.retries) {
+          await wait(getRetryDelayMs(attempt + 1, policy));
+          continue;
+        }
+        throw new SagepilotChatError("network_error", init.errorMessage, { cause: error });
+      }
+      if (canRetry && !response.ok && attempt < policy.retries && shouldRetryStatus(response.status, policy)) {
+        await wait(getRetryDelayMs(attempt + 1, policy));
+        continue;
+      }
+      const body = await readResponseJson(response);
+      if (!response.ok) {
+        const errorBody = body;
+        const apiError = errorBody.error;
+        const message = typeof apiError === "string" ? apiError : apiError?.message || init.errorMessage;
+        throw new SagepilotChatError(
+          typeof apiError === "string" ? "invalid_response" : normalizeErrorCode(apiError?.code),
+          message,
+          {
+            status: response.status,
+            requestId: typeof apiError === "string" ? void 0 : apiError?.request_id,
+            details: typeof apiError === "string" ? void 0 : apiError?.details
+          }
+        );
+      }
+      return body;
+    }
+    throw new SagepilotChatError("network_error", init.errorMessage, { cause: lastNetworkError });
+  }
+};
+
+// src/core/native/deviceInfo.ts
+async function resolveDeviceInfo(adapter) {
+  if (!adapter) return {};
+  return adapter.getDeviceInfo();
+}
+
+// src/resources/channels.ts
+function bootstrapChannel(http, host, channelId) {
+  return http.request(
+    `${host}${CUSTOMER_API_PREFIX}/channels/${encodeURIComponent(channelId)}/bootstrap`,
+    {
+      method: "GET",
+      errorMessage: `${SDK_NAME} Failed to load channel configuration.`
+    }
+  );
+}
+
+// src/resources/sessions.ts
+function createSession(http, host, channelId, input) {
+  return http.request(
+    `${host}${CUSTOMER_API_PREFIX}/sessions`,
+    {
+      method: "POST",
+      headers: withJsonHeaders(void 0),
+      body: JSON.stringify({
+        channel_id: channelId,
+        anonymous_id: input.anonymousId,
+        metadata: {
+          platform: "react_native",
+          sdk: SDK_NAME,
+          sdk_version: SDK_VERSION,
+          ...input.metadata
+        }
+      }),
+      errorMessage: `${SDK_NAME} Failed to create customer session.`
+    }
+  );
+}
+function getSession(http, host, sessionId, authorizationHeader) {
+  return http.request(
+    `${host}${CUSTOMER_API_PREFIX}/sessions/${encodeURIComponent(sessionId)}`,
+    {
+      method: "GET",
+      headers: authorizationHeader,
+      errorMessage: `${SDK_NAME} Failed to load customer session.`
+    }
+  );
+}
+function identifySession(http, host, channelId, sessionId, authorizationHeader, identity) {
+  return http.request(
+    `${host}${CUSTOMER_API_PREFIX}/sessions/${encodeURIComponent(sessionId)}/identify`,
+    {
+      method: "POST",
+      headers: withJsonHeaders(authorizationHeader),
+      body: JSON.stringify({
+        channel_id: channelId,
+        identity
+      }),
+      errorMessage: `${SDK_NAME} Failed to identify customer.`
+    }
+  );
+}
+function logoutSession(http, host, sessionId, authorizationHeader) {
+  return http.request(
+    `${host}${CUSTOMER_API_PREFIX}/sessions/${encodeURIComponent(sessionId)}/logout`,
+    {
+      method: "POST",
+      headers: authorizationHeader,
+      errorMessage: `${SDK_NAME} Failed to logout customer session.`
+    }
+  );
+}
+
+// src/resources/unread.ts
+function fetchUnreadCount(http, host, channelId, sessionId, authorizationHeader) {
+  const url = new URL(`${host}${CUSTOMER_API_PREFIX}/unread-count`);
+  url.searchParams.set("channel_id", channelId);
+  url.searchParams.set("session_id", sessionId);
+  return http.request(
+    url.toString(),
+    {
+      method: "GET",
+      headers: authorizationHeader,
+      errorMessage: `${SDK_NAME} Failed to fetch unread count.`
+    }
+  );
+}
+
+// src/public/SdkClient.ts
+var DEFAULT_MOBILE_LAUNCHER_CONFIG = {
+  label: "Chat",
+  buttonColor: "#173c2d",
+  pressedButtonColor: "#225340",
+  disabledButtonColor: "#d8cdbb",
+  borderColor: "#2a5e49",
+  disabledBorderColor: "#cbbda9",
+  iconColor: "#fff8ef",
+  iconInsideColor: "#173c2d",
+  labelColor: "#d4e9dc",
+  disabledContentColor: "#8d8172",
+  unreadBadgeColor: "#e76f51",
+  unreadBadgeTextColor: "#ffffff",
+  unreadBadgeBorderColor: "#efe4d4"
+};
+function resolveMobileLauncherConfig(theme) {
+  const launcher = theme?.launcher ?? {};
+  const accentColor = theme?.accentColor;
+  const primaryColor = launcher.buttonColor ?? accentColor ?? DEFAULT_MOBILE_LAUNCHER_CONFIG.buttonColor;
+  return {
+    label: launcher.label ?? DEFAULT_MOBILE_LAUNCHER_CONFIG.label,
+    buttonColor: primaryColor,
+    pressedButtonColor: launcher.pressedButtonColor ?? primaryColor,
+    disabledButtonColor: launcher.disabledButtonColor ?? DEFAULT_MOBILE_LAUNCHER_CONFIG.disabledButtonColor,
+    borderColor: launcher.borderColor ?? primaryColor,
+    disabledBorderColor: launcher.disabledBorderColor ?? DEFAULT_MOBILE_LAUNCHER_CONFIG.disabledBorderColor,
+    iconColor: launcher.iconColor ?? DEFAULT_MOBILE_LAUNCHER_CONFIG.iconColor,
+    iconInsideColor: launcher.iconInsideColor ?? primaryColor,
+    labelColor: launcher.labelColor ?? DEFAULT_MOBILE_LAUNCHER_CONFIG.labelColor,
+    disabledContentColor: launcher.disabledContentColor ?? DEFAULT_MOBILE_LAUNCHER_CONFIG.disabledContentColor,
+    unreadBadgeColor: launcher.unreadBadgeColor ?? DEFAULT_MOBILE_LAUNCHER_CONFIG.unreadBadgeColor,
+    unreadBadgeTextColor: launcher.unreadBadgeTextColor ?? DEFAULT_MOBILE_LAUNCHER_CONFIG.unreadBadgeTextColor,
+    unreadBadgeBorderColor: launcher.unreadBadgeBorderColor ?? DEFAULT_MOBILE_LAUNCHER_CONFIG.unreadBadgeBorderColor
+  };
+}
+function resolveMobileThemeState(theme) {
+  return {
+    accentColor: theme?.accentColor,
+    logoUrl: theme?.logoUrl,
+    preferredColorScheme: theme?.preferredColorScheme,
+    launcher: resolveMobileLauncherConfig(theme)
+  };
+}
+function normalizeIdentity(identity) {
+  const userId = identity?.userId ?? identity?.user_id;
+  if (!userId) {
+    throw new SagepilotChatError("invalid_config", `${SDK_NAME} identify() requires userId.`);
+  }
+  return {
+    user_id: userId,
+    email: identity.email,
+    name: identity.name,
+    phone: identity.phone,
+    custom_properties: identity.customProperties ?? identity.custom_properties,
+    user_hash: identity.userHash ?? identity.user_hash
+  };
+}
+function toPublicSessionState(session) {
+  return {
+    session_id: session.session_id,
+    customer_id: session.customer_id ?? null,
+    conversation_id: session.conversation_id ?? null,
+    authenticated: session.authenticated ?? false,
+    updated_at: "updated_at" in session ? session.updated_at : void 0
+  };
+}
+var SagepilotReactNativeChat = class {
+  constructor() {
+    this.sdkName = SDK_NAME;
+    this.runtimeOptions = null;
+    this.http = null;
+    this.sessionManager = null;
+    this.apiHost = "";
+    this.widgetHost = "";
+    this.workspaceId = "";
+    this.channelId = "";
+    this.channel = null;
+    this.session = null;
+    this.customer = null;
+    this.legacyWidgetJwt = null;
+    this.lastIdentifyResult = null;
+    this.identified = false;
+    this.identifyPending = false;
+    this.isConfigured = false;
+    this.presented = false;
+    this.hostedChatView = { screen: "home" };
+    this.unreadCount = 0;
+    this.unreadPollTimer = null;
+    this.stateCallbacks = /* @__PURE__ */ new Set();
+    this.identifyCallbacks = /* @__PURE__ */ new Set();
+    this.unreadCallbacks = /* @__PURE__ */ new Set();
+    this.readyCallbacks = /* @__PURE__ */ new Set();
+    this.presentCallbacks = /* @__PURE__ */ new Set();
+    this.dismissCallbacks = /* @__PURE__ */ new Set();
+    this.errorCallbacks = /* @__PURE__ */ new Set();
+  }
+  async configure(config) {
+    if (this.isConfigured) {
+      throw new SagepilotChatError(
+        "already_initialized",
+        `${SDK_NAME} is already configured. Call destroy() before configuring again.`
+      );
+    }
+    if (!config?.key || typeof config.key !== "string") {
+      throw new SagepilotChatError(
+        "invalid_config",
+        `${SDK_NAME} requires a key in the format "workspace_id:channel_id".`
+      );
+    }
+    const { workspaceId, channelId } = parseKey(config.key);
+    this.runtimeOptions = {
+      behavior: config.behavior,
+      presentation: config.presentation,
+      theme: config.theme,
+      hostedClaimsStorageKeyPrefix: config.hostedClaimsStorageKeyPrefix || DEFAULT_HOSTED_CLAIMS_STORAGE_KEY_PREFIX
+    };
+    const fetchImpl = resolveFetch(config.fetch);
+    const publicHost = resolveSagepilotHost(config.host);
+    this.widgetHost = normalizeHost(config.widgetHost || DEFAULT_WIDGET_HOST);
+    this.apiHost = resolveCustomerApiHost(config.apiHost, publicHost);
+    this.workspaceId = workspaceId;
+    this.channelId = channelId;
+    this.http = new SagepilotHttpClient({
+      fetch: fetchImpl,
+      headers: config.headers
+    });
+    this.sessionManager = new SagepilotSessionManager(
+      new SagepilotTokenManager(this.channelId, config.tokenStorage ?? createMemoryTokenStorage())
+    );
+    try {
+      const channel = await bootstrapChannel(this.requireHttp(), this.apiHost, this.channelId);
+      if (channel.workspace_id !== this.workspaceId) {
+        throw new SagepilotChatError(
+          "forbidden",
+          `${SDK_NAME} The workspace id in the key does not match this channel.`,
+          { details: { channel_id: this.channelId } }
+        );
+      }
+      const session = await this.resolveCustomerSession(config);
+      this.channel = channel;
+      this.session = session;
+      this.isConfigured = true;
+      this.emitReady();
+      this.emitState();
+      if (config.behavior?.enableUnreadPolling ?? true) {
+        this.startUnreadPolling(config.behavior?.unreadPollIntervalMs);
+      }
+      return { channel, session: toPublicSessionState(session) };
+    } catch (error) {
+      this.resetRuntimeState();
+      this.emitError(error);
+      throw error;
+    }
+  }
+  async getSession() {
+    const session = this.requireSession();
+    const liveSession = await getSession(
+      this.requireHttp(),
+      this.apiHost,
+      session.session_id,
+      this.requireSessionManager().getAuthorizationHeader(session.session_token)
+    );
+    return toPublicSessionState({
+      ...session,
+      customer_id: liveSession.customer_id,
+      conversation_id: liveSession.conversation_id,
+      authenticated: liveSession.authenticated ?? session.authenticated ?? false
+    });
+  }
+  async identify(identity) {
+    const session = this.requireSession();
+    const apiIdentity = normalizeIdentity(identity);
+    this.identifyPending = true;
+    this.emitState();
+    try {
+      const result = await identifySession(
+        this.requireHttp(),
+        this.apiHost,
+        this.channelId,
+        session.session_id,
+        this.requireSessionManager().getAuthorizationHeader(session.session_token),
+        apiIdentity
+      );
+      const updatedSession = await this.requireSessionManager().setSession({
+        ...session,
+        session_token: result.session_token,
+        customer_id: result.customer_id,
+        conversation_id: result.conversation_id,
+        authenticated: true
+      });
+      this.session = updatedSession;
+      this.customer = result.customer;
+      this.legacyWidgetJwt = result.legacy_jwt ?? null;
+      this.identified = true;
+      this.identifyPending = false;
+      const { session_token: _sessionToken, legacy_jwt: _legacyWidgetJwt, ...safeResult } = result;
+      const publicResult = {
+        ...safeResult,
+        success: true
+      };
+      this.lastIdentifyResult = publicResult;
+      this.identifyCallbacks.forEach((callback) => callback(publicResult));
+      this.emitState();
+      return publicResult;
+    } catch (error) {
+      this.identifyPending = false;
+      this.emitState();
+      this.emitError(error);
+      throw error;
+    }
+  }
+  async logout() {
+    const session = this.requireSession();
+    const result = await logoutSession(
+      this.requireHttp(),
+      this.apiHost,
+      session.session_id,
+      this.requireSessionManager().getAuthorizationHeader(session.session_token)
+    );
+    this.identified = false;
+    this.customer = null;
+    this.legacyWidgetJwt = null;
+    this.lastIdentifyResult = null;
+    this.session = await this.requireSessionManager().setSession({
+      ...session,
+      customer_id: null,
+      conversation_id: null,
+      authenticated: false
+    });
+    this.setUnreadCount(0);
+    this.emitState();
+    return result;
+  }
+  getIdentityState() {
+    return {
+      identified: this.identified,
+      customer: this.customer,
+      pending: this.identifyPending
+    };
+  }
+  onIdentify(callback) {
+    if (typeof callback !== "function") return () => void 0;
+    this.identifyCallbacks.add(callback);
+    if (this.identified && this.lastIdentifyResult) {
+      callback(this.lastIdentifyResult);
+    }
+    return () => {
+      this.identifyCallbacks.delete(callback);
+    };
+  }
+  async getUnreadCount() {
+    if (!this.isConfigured || !this.session) return this.unreadCount;
+    return this.fetchUnreadCount();
+  }
+  onUnreadChange(callback) {
+    if (typeof callback !== "function") return () => void 0;
+    this.unreadCallbacks.add(callback);
+    callback(this.getUnreadState());
+    return () => {
+      this.unreadCallbacks.delete(callback);
+    };
+  }
+  startUnreadPolling(intervalMs = this.runtimeOptions?.behavior?.unreadPollIntervalMs ?? DEFAULT_UNREAD_POLL_INTERVAL_MS) {
+    this.stopUnreadPolling();
+    void this.fetchUnreadCount().catch((error) => this.emitError(error));
+    this.unreadPollTimer = setInterval(() => {
+      void this.fetchUnreadCount().catch((error) => this.emitError(error));
+    }, intervalMs);
+    return () => this.stopUnreadPolling();
+  }
+  stopUnreadPolling() {
+    if (this.unreadPollTimer) {
+      clearInterval(this.unreadPollTimer);
+      this.unreadPollTimer = null;
+    }
+  }
+  present() {
+    this.requireConfigured();
+    this.hostedChatView = { screen: "home" };
+    if (this.presented) {
+      this.emitState();
+      return true;
+    }
+    this.presented = true;
+    this.setUnreadCount(0);
+    this.presentCallbacks.forEach((callback) => callback(this.getLifecycleState()));
+    this.emitState();
+    return true;
+  }
+  presentMessages() {
+    this.requireConfigured();
+    this.hostedChatView = { screen: "messages" };
+    return this.showHostedChat();
+  }
+  presentMessageComposer(message) {
+    this.requireConfigured();
+    this.hostedChatView = { screen: "composer", message };
+    return this.showHostedChat();
+  }
+  dismiss() {
+    this.requireConfigured();
+    if (!this.presented) return true;
+    this.presented = false;
+    this.emitUnreadChange();
+    this.dismissCallbacks.forEach((callback) => callback(this.getLifecycleState()));
+    this.emitState();
+    return true;
+  }
+  hide() {
+    return this.dismiss();
+  }
+  toggle() {
+    if (this.presented) {
+      this.dismiss();
+      return false;
+    }
+    this.present();
+    return true;
+  }
+  isPresented() {
+    return this.presented;
+  }
+  onReady(callback) {
+    if (typeof callback !== "function") return () => void 0;
+    this.readyCallbacks.add(callback);
+    if (this.isConfigured) callback(this.getLifecycleState());
+    return () => {
+      this.readyCallbacks.delete(callback);
+    };
+  }
+  onPresent(callback) {
+    if (typeof callback !== "function") return () => void 0;
+    this.presentCallbacks.add(callback);
+    if (this.presented) callback(this.getLifecycleState());
+    return () => {
+      this.presentCallbacks.delete(callback);
+    };
+  }
+  onDismiss(callback) {
+    if (typeof callback !== "function") return () => void 0;
+    this.dismissCallbacks.add(callback);
+    return () => {
+      this.dismissCallbacks.delete(callback);
+    };
+  }
+  onError(callback) {
+    if (typeof callback !== "function") return () => void 0;
+    this.errorCallbacks.add(callback);
+    return () => {
+      this.errorCallbacks.delete(callback);
+    };
+  }
+  onStateChange(callback) {
+    if (typeof callback !== "function") return () => void 0;
+    this.stateCallbacks.add(callback);
+    callback(this.getState());
+    return () => {
+      this.stateCallbacks.delete(callback);
+    };
+  }
+  getState() {
+    return {
+      configured: this.isConfigured,
+      isOpen: this.isPresented(),
+      unreadCount: this.unreadCount,
+      identity: this.getIdentityState(),
+      theme: resolveMobileThemeState(this.runtimeOptions?.theme)
+    };
+  }
+  getSessionState() {
+    return this.session ? toPublicSessionState(this.session) : null;
+  }
+  getChannel() {
+    return this.channel;
+  }
+  getConfig() {
+    return this.runtimeOptions;
+  }
+  getConversationUrl() {
+    this.requireConfigured();
+    const session = this.requireSession();
+    const path = this.hostedChatView.screen === "home" ? `/chat-widget/${encodeURIComponent(this.channelId)}` : `/chat-widget/${encodeURIComponent(this.channelId)}/conversations`;
+    const url = new URL(`${this.widgetHost}${path}`);
+    url.searchParams.set("sdk", "react-native");
+    if (this.runtimeOptions?.presentation?.mobile ?? true) {
+      url.searchParams.set("mobile", "1");
+    }
+    if (this.runtimeOptions?.presentation?.showCloseButton ?? false) {
+      url.searchParams.set("hideCloseButton", "true");
+    }
+    url.searchParams.set("session_id", session.session_id);
+    url.searchParams.set("wid", this.workspaceId);
+    if (this.hostedChatView.screen === "composer") {
+      url.searchParams.set("new", "true");
+      if (this.hostedChatView.message) {
+        url.searchParams.set("topic", this.hostedChatView.message);
+      }
+    }
+    return url.toString();
+  }
+  getPreloadUrl() {
+    this.requireConfigured();
+    const previousView = this.hostedChatView;
+    this.hostedChatView = { screen: "home" };
+    const preloadUrl = this.getConversationUrl();
+    this.hostedChatView = previousView;
+    return preloadUrl;
+  }
+  getHostedAuthScript() {
+    if (!this.legacyWidgetJwt || !this.workspaceId) return "";
+    const storageKey = `${this.runtimeOptions?.hostedClaimsStorageKeyPrefix || DEFAULT_HOSTED_CLAIMS_STORAGE_KEY_PREFIX}_${this.workspaceId}`;
+    return [
+      "(function(){",
+      "try {",
+      `window.localStorage.setItem(${JSON.stringify(storageKey)}, ${JSON.stringify(this.legacyWidgetJwt)});`,
+      "} catch (_) {}",
+      "})();"
+    ].join("\n");
+  }
+  handleHostedBridgeMessage(message) {
+    if (!message) return false;
+    if (message.type === "close_widget") {
+      this.dismiss();
+      return true;
+    }
+    if (message.type === "unread_count") {
+      const nextCount = message.count ?? message.unread_count;
+      if (typeof nextCount === "number") {
+        this.setUnreadCount(nextCount);
+      } else {
+        void this.getUnreadCount().catch((error) => this.emitError(error));
+      }
+      return true;
+    }
+    if (message.type === "sagepilot:error") {
+      this.emitError(message);
+      return true;
+    }
+    return true;
+  }
+  destroy() {
+    this.stopUnreadPolling();
+    this.resetRuntimeState();
+    this.emitState();
+    this.identifyCallbacks.clear();
+    this.unreadCallbacks.clear();
+    this.readyCallbacks.clear();
+    this.presentCallbacks.clear();
+    this.dismissCallbacks.clear();
+    this.errorCallbacks.clear();
+  }
+  setUnreadCount(count) {
+    if (count === this.unreadCount) return;
+    this.unreadCount = count;
+    this.emitUnreadChange();
+  }
+  emitUnreadChange() {
+    const state = this.getUnreadState();
+    this.unreadCallbacks.forEach((callback) => callback(state));
+  }
+  emitReady() {
+    const state = this.getLifecycleState();
+    this.readyCallbacks.forEach((callback) => callback(state));
+  }
+  emitError(error) {
+    this.errorCallbacks.forEach((callback) => callback(error));
+  }
+  getUnreadState() {
+    return {
+      count: this.unreadCount,
+      isOpen: this.presented
+    };
+  }
+  getLifecycleState() {
+    return {
+      isOpen: this.presented,
+      unreadCount: this.unreadCount
+    };
+  }
+  emitState() {
+    const state = this.getState();
+    this.stateCallbacks.forEach((callback) => callback(state));
+  }
+  requireConfigured() {
+    if (!this.isConfigured || !this.session) {
+      throw new SagepilotChatError(
+        "not_initialized",
+        `${SDK_NAME} is not configured. Call configure() first.`
+      );
+    }
+  }
+  requireSession() {
+    this.requireConfigured();
+    return this.session;
+  }
+  requireHttp() {
+    if (!this.http) {
+      throw new SagepilotChatError(
+        "not_initialized",
+        `${SDK_NAME} is not configured. Call configure() first.`
+      );
+    }
+    return this.http;
+  }
+  requireSessionManager() {
+    if (!this.sessionManager) {
+      throw new SagepilotChatError(
+        "not_initialized",
+        `${SDK_NAME} is not configured. Call configure() first.`
+      );
+    }
+    return this.sessionManager;
+  }
+  async resolveCustomerSession(config) {
+    const sessionManager = this.requireSessionManager();
+    const storedSession = await sessionManager.hydrate();
+    if (storedSession?.session_id && storedSession.session_token) {
+      try {
+        const liveSession = await getSession(
+          this.requireHttp(),
+          this.apiHost,
+          storedSession.session_id,
+          sessionManager.getAuthorizationHeader(storedSession.session_token)
+        );
+        const session2 = await sessionManager.setSession({
+          ...storedSession,
+          customer_id: liveSession.customer_id,
+          conversation_id: liveSession.conversation_id,
+          authenticated: liveSession.authenticated ?? storedSession.authenticated ?? false
+        });
+        return {
+          ...liveSession,
+          session_token: session2.session_token
+        };
+      } catch {
+        await sessionManager.clearSession();
+      }
+    }
+    const deviceInfo = await resolveDeviceInfo(config.deviceInfo);
+    const session = await createSession(
+      this.requireHttp(),
+      this.apiHost,
+      this.channelId,
+      {
+        anonymousId: config.anonymousId,
+        metadata: {
+          ...config.metadata,
+          device: deviceInfo,
+          presentation: config.presentation,
+          theme: config.theme,
+          push_notifications_enabled: config.behavior?.enablePushNotifications
+        }
+      }
+    );
+    await sessionManager.setSession(session);
+    return session;
+  }
+  async fetchUnreadCount() {
+    const session = this.requireSession();
+    const response = await fetchUnreadCount(
+      this.requireHttp(),
+      this.apiHost,
+      this.channelId,
+      session.session_id,
+      this.requireSessionManager().getAuthorizationHeader(session.session_token)
+    );
+    this.setUnreadCount(response.unread_count || 0);
+    return this.unreadCount;
+  }
+  resetRuntimeState() {
+    this.runtimeOptions = null;
+    this.http = null;
+    this.sessionManager = null;
+    this.apiHost = "";
+    this.widgetHost = "";
+    this.workspaceId = "";
+    this.channelId = "";
+    this.channel = null;
+    this.session = null;
+    this.customer = null;
+    this.legacyWidgetJwt = null;
+    this.lastIdentifyResult = null;
+    this.identified = false;
+    this.identifyPending = false;
+    this.isConfigured = false;
+    this.presented = false;
+    this.hostedChatView = { screen: "home" };
+    this.unreadCount = 0;
+  }
+  showHostedChat() {
+    if (!this.presented) {
+      this.presented = true;
+      this.setUnreadCount(0);
+      this.presentCallbacks.forEach((callback) => callback(this.getLifecycleState()));
+    }
+    this.emitState();
+    return true;
+  }
+};
+var internalSagepilotChat = new SagepilotReactNativeChat();
+var SagepilotChat = {
+  configure: (config) => internalSagepilotChat.configure(config),
+  getSession: () => internalSagepilotChat.getSession(),
+  identify: (identity) => internalSagepilotChat.identify(identity),
+  logout: () => internalSagepilotChat.logout(),
+  getIdentityState: () => internalSagepilotChat.getIdentityState(),
+  onIdentify: (callback) => internalSagepilotChat.onIdentify(callback),
+  getUnreadCount: () => internalSagepilotChat.getUnreadCount(),
+  onUnreadChange: (callback) => internalSagepilotChat.onUnreadChange(callback),
+  startUnreadPolling: (intervalMs) => internalSagepilotChat.startUnreadPolling(intervalMs),
+  stopUnreadPolling: () => internalSagepilotChat.stopUnreadPolling(),
+  present: () => internalSagepilotChat.present(),
+  presentMessages: () => internalSagepilotChat.presentMessages(),
+  presentMessageComposer: (message) => internalSagepilotChat.presentMessageComposer(message),
+  dismiss: () => internalSagepilotChat.dismiss(),
+  hide: () => internalSagepilotChat.hide(),
+  toggle: () => internalSagepilotChat.toggle(),
+  isPresented: () => internalSagepilotChat.isPresented(),
+  onReady: (callback) => internalSagepilotChat.onReady(callback),
+  onPresent: (callback) => internalSagepilotChat.onPresent(callback),
+  onDismiss: (callback) => internalSagepilotChat.onDismiss(callback),
+  onError: (callback) => internalSagepilotChat.onError(callback),
+  onStateChange: (callback) => internalSagepilotChat.onStateChange(callback),
+  getState: () => internalSagepilotChat.getState(),
+  getSessionState: () => internalSagepilotChat.getSessionState(),
+  getChannel: () => internalSagepilotChat.getChannel(),
+  destroy: () => internalSagepilotChat.destroy()
+};
+
+// src/core/storage/cache.ts
+function createAsyncStorageCacheStorage(asyncStorage) {
+  return {
+    getItem: (key) => asyncStorage.getItem(key),
+    setItem: (key, value) => asyncStorage.setItem(key, value),
+    removeItem: (key) => asyncStorage.removeItem(key)
+  };
+}
+
+// src/ui/SagepilotChatProvider.ts
+import { createElement, useEffect, useState } from "react";
+import {
+  ActivityIndicator,
+  Modal,
+  Platform,
+  Pressable,
+  StyleSheet,
+  Text,
+  View
+} from "react-native";
+import { WebView } from "react-native-webview";
+
+// src/core/webview/mobileBridge.ts
+function isHostedBridgeMessage(value) {
+  if (!value || typeof value !== "object") return false;
+  const message = value;
+  return typeof message.type === "string";
+}
+function parseHostedBridgeMessage(rawData) {
+  if (!rawData) return null;
+  if (isHostedBridgeMessage(rawData)) {
+    return rawData;
+  }
+  if (typeof rawData !== "string") {
+    return null;
+  }
+  try {
+    const message = JSON.parse(rawData);
+    return isHostedBridgeMessage(message) ? message : null;
+  } catch {
+    return null;
+  }
+}
+var mobileWebViewBridgeScript = `
+  (function () {
+    if (window.__sagepilotRnBridgeInstalled) return true;
+    window.__sagepilotRnBridgeInstalled = true;
+
+    var ensureViewport = function () {
+      var viewport = document.querySelector('meta[name="viewport"]');
+      if (!viewport) {
+        viewport = document.createElement("meta");
+        viewport.setAttribute("name", "viewport");
+        document.head.appendChild(viewport);
+      }
+      viewport.setAttribute("content", "width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover");
+    };
+
+    var injectMobileStyles = function () {
+      if (document.getElementById("sagepilot-rn-mobile-style")) return;
+      var style = document.createElement("style");
+      style.id = "sagepilot-rn-mobile-style";
+      style.textContent = [
+        "html, body { overscroll-behavior: none; -webkit-text-size-adjust: 100%; }",
+        "body { -webkit-tap-highlight-color: transparent; touch-action: manipulation; }",
+        "input, textarea, [contenteditable='true'] { -webkit-user-select: text; user-select: text; }",
+        "*:not(input):not(textarea):not([contenteditable='true']) { -webkit-user-select: none; user-select: none; }"
+      ].join("\\n");
+      document.head.appendChild(style);
+    };
+
+    var sendToReactNative = function (message) {
+      try {
+        if (window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === "function") {
+          window.ReactNativeWebView.postMessage(typeof message === "string" ? message : JSON.stringify(message));
+        }
+      } catch (error) {}
+    };
+
+    var originalPostMessage = window.postMessage;
+    window.postMessage = function (message, targetOrigin, transfer) {
+      sendToReactNative(message);
+      return originalPostMessage.apply(window, arguments);
+    };
+
+    window.SagepilotMobileBridge = {
+      postMessage: sendToReactNative,
+      ready: function () { sendToReactNative({ type: "sagepilot:ready" }); }
+    };
+
+    document.addEventListener("click", function (event) {
+      try {
+        var target = event.target && event.target.closest
+          ? event.target
+          : event.target && event.target.parentElement;
+        if (target && target.closest && target.closest("[data-sagepilot-close-widget='true']")) {
+          sendToReactNative({ type: "close_widget" });
+        }
+      } catch (error) {}
+    }, true);
+
+    ensureViewport();
+    injectMobileStyles();
+    sendToReactNative({ type: "sagepilot:ready" });
+    return true;
+  })();
+`;
+
+// src/ui/SagepilotChatProvider.ts
+function readPresentationState() {
+  return {
+    isPresented: internalSagepilotChat.isPresented(),
+    configured: internalSagepilotChat.getState().configured,
+    conversationUrl: internalSagepilotChat.getState().configured ? internalSagepilotChat.getConversationUrl() : null,
+    preloadUrl: internalSagepilotChat.getState().configured ? internalSagepilotChat.getPreloadUrl() : null,
+    shouldPreload: internalSagepilotChat.getConfig()?.behavior?.preloadWebView ?? true,
+    presentation: internalSagepilotChat.getConfig()?.presentation
+  };
+}
+function getInjectedWebViewScript() {
+  return [
+    internalSagepilotChat.getHostedAuthScript(),
+    mobileWebViewBridgeScript
+  ].filter(Boolean).join("\n");
+}
+function readUrlOrigin(url) {
+  if (!url) return null;
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+var hostedChatWebViewProps = {
+  allowFileAccess: true,
+  allowFileAccessFromFileURLs: true,
+  domStorageEnabled: true,
+  javaScriptEnabled: true,
+  setSupportMultipleWindows: false,
+  sharedCookiesEnabled: true,
+  thirdPartyCookiesEnabled: true
+};
+function SagepilotChatProvider({
+  children,
+  closeLabel = "Close",
+  loadingLabel = "Loading chat"
+}) {
+  const [state, setState] = useState(readPresentationState);
+  useEffect(() => {
+    return internalSagepilotChat.onStateChange(() => {
+      setState(readPresentationState());
+    });
+  }, []);
+  const showCloseButton = state.presentation?.showCloseButton ?? false;
+  const presentationStyle = state.presentation?.style ?? "sheet";
+  const animationType = presentationStyle === "fullScreen" || presentationStyle === "push" ? "slide" : "fade";
+  const handleWebViewMessage = (event) => {
+    internalSagepilotChat.handleHostedBridgeMessage(parseHostedBridgeMessage(event.nativeEvent?.data));
+  };
+  useEffect(() => {
+    if (Platform.OS !== "web" || typeof window === "undefined") return;
+    const trustedWidgetOrigin = readUrlOrigin(state.conversationUrl);
+    if (!trustedWidgetOrigin) return;
+    const handleWindowMessage = (event) => {
+      if (event.origin !== trustedWidgetOrigin) return;
+      internalSagepilotChat.handleHostedBridgeMessage(parseHostedBridgeMessage(event.data));
+    };
+    window.addEventListener("message", handleWindowMessage);
+    return () => window.removeEventListener("message", handleWindowMessage);
+  }, [state.conversationUrl]);
+  if (Platform.OS === "web") {
+    return createElement(
+      View,
+      { style: styles.root },
+      children,
+      state.configured && !state.isPresented && state.shouldPreload && state.preloadUrl ? createElement("iframe", {
+        src: state.preloadUrl,
+        style: styles.webPreloadFrame,
+        title: "Sagepilot chat preload"
+      }) : null,
+      state.configured && state.isPresented && state.conversationUrl ? createElement(
+        View,
+        { style: styles.webOverlay },
+        createElement(
+          View,
+          { style: styles.webPanel },
+          showCloseButton ? createElement(
+            Pressable,
+            {
+              accessibilityRole: "button",
+              accessibilityLabel: closeLabel,
+              onPress: () => internalSagepilotChat.dismiss(),
+              style: styles.webCloseButton
+            },
+            createElement(Text, { style: styles.closeText }, closeLabel)
+          ) : null,
+          createElement("iframe", {
+            src: state.conversationUrl,
+            style: styles.webFrame,
+            title: "Sagepilot chat"
+          })
+        )
+      ) : null
+    );
+  }
+  return createElement(
+    View,
+    { style: styles.root },
+    children,
+    state.configured && !state.isPresented && state.shouldPreload && state.preloadUrl ? createElement(WebView, {
+      ...hostedChatWebViewProps,
+      source: { uri: state.preloadUrl },
+      style: styles.preloadWebview,
+      injectedJavaScriptBeforeContentLoaded: getInjectedWebViewScript(),
+      onMessage: handleWebViewMessage
+    }) : null,
+    createElement(
+      Modal,
+      {
+        visible: state.configured && state.isPresented,
+        animationType,
+        presentationStyle: presentationStyle === "fullScreen" ? "fullScreen" : "pageSheet",
+        onRequestClose: () => internalSagepilotChat.dismiss()
+      },
+      createElement(
+        View,
+        { style: styles.container },
+        showCloseButton ? createElement(
+          View,
+          { style: styles.header },
+          createElement(
+            Pressable,
+            {
+              accessibilityRole: "button",
+              accessibilityLabel: closeLabel,
+              onPress: () => internalSagepilotChat.dismiss(),
+              style: styles.closeButton
+            },
+            createElement(Text, { style: styles.closeText }, closeLabel)
+          )
+        ) : null,
+        state.conversationUrl ? createElement(WebView, {
+          ...hostedChatWebViewProps,
+          source: { uri: state.conversationUrl },
+          style: styles.webview,
+          startInLoadingState: true,
+          injectedJavaScriptBeforeContentLoaded: getInjectedWebViewScript(),
+          onMessage: handleWebViewMessage,
+          renderLoading: () => createElement(
+            View,
+            { style: styles.loading },
+            createElement(ActivityIndicator, null),
+            createElement(Text, { style: styles.loadingText }, loadingLabel)
+          )
+        }) : null
+      )
+    )
+  );
+}
+var styles = StyleSheet.create({
+  root: {
+    flex: 1
+  },
+  container: {
+    flex: 1,
+    backgroundColor: "#ffffff"
+  },
+  header: {
+    minHeight: 48,
+    alignItems: "flex-end",
+    justifyContent: "center",
+    paddingHorizontal: 12,
+    borderBottomWidth: 1,
+    borderBottomColor: "#e5e7eb"
+  },
+  closeButton: {
+    minHeight: 36,
+    justifyContent: "center",
+    paddingHorizontal: 8
+  },
+  closeText: {
+    color: "#111827",
+    fontSize: 16,
+    fontWeight: "600"
+  },
+  webview: {
+    flex: 1
+  },
+  preloadWebview: {
+    position: "absolute",
+    width: 1,
+    height: 1,
+    opacity: 0
+  },
+  webOverlay: {
+    position: "absolute",
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    zIndex: 9999,
+    backgroundColor: "rgba(17, 24, 39, 0.36)"
+  },
+  webPanel: {
+    position: "absolute",
+    right: 24,
+    bottom: 24,
+    width: 420,
+    maxWidth: "calc(100vw - 32px)",
+    height: 680,
+    maxHeight: "calc(100vh - 32px)",
+    overflow: "hidden",
+    borderRadius: 16,
+    backgroundColor: "#ffffff",
+    boxShadow: "0 24px 80px rgba(17, 24, 39, 0.28)"
+  },
+  webCloseButton: {
+    minHeight: 44,
+    alignItems: "flex-end",
+    justifyContent: "center",
+    paddingHorizontal: 14,
+    borderBottomWidth: 1,
+    borderBottomColor: "#e5e7eb"
+  },
+  webFrame: {
+    width: "100%",
+    height: "calc(100% - 45px)",
+    borderWidth: 0,
+    borderStyle: "none"
+  },
+  webPreloadFrame: {
+    position: "absolute",
+    width: 1,
+    height: 1,
+    opacity: 0,
+    pointerEvents: "none",
+    borderWidth: 0,
+    borderStyle: "none"
+  },
+  loading: {
+    ...StyleSheet.absoluteFillObject,
+    alignItems: "center",
+    justifyContent: "center",
+    backgroundColor: "#ffffff"
+  },
+  loadingText: {
+    marginTop: 12,
+    color: "#4b5563",
+    fontSize: 14
+  }
+});
+
+// src/hooks/useSagepilotChat.ts
+import { useCallback, useEffect as useEffect2, useState as useState2 } from "react";
+function readState() {
+  const state = SagepilotChat.getState();
+  return {
+    configured: state.configured,
+    isPresented: state.isOpen,
+    unreadCount: state.unreadCount,
+    identity: state.identity,
+    theme: state.theme
+  };
+}
+function useSagepilotChat() {
+  const [state, setState] = useState2(readState);
+  useEffect2(() => {
+    return SagepilotChat.onStateChange(() => {
+      setState(readState());
+    });
+  }, []);
+  const present = useCallback(() => SagepilotChat.present(), []);
+  const presentMessages = useCallback(() => SagepilotChat.presentMessages(), []);
+  const presentMessageComposer = useCallback((message) => SagepilotChat.presentMessageComposer(message), []);
+  const dismiss = useCallback(() => SagepilotChat.dismiss(), []);
+  const hide = useCallback(() => SagepilotChat.hide(), []);
+  const toggle = useCallback(() => SagepilotChat.toggle(), []);
+  const identify = useCallback((identity) => {
+    return SagepilotChat.identify(identity);
+  }, []);
+  const logout = useCallback(() => SagepilotChat.logout(), []);
+  const getUnreadCount = useCallback(() => SagepilotChat.getUnreadCount(), []);
+  return {
+    ...state,
+    present,
+    presentMessages,
+    presentMessageComposer,
+    dismiss,
+    hide,
+    toggle,
+    identify,
+    logout,
+    getUnreadCount
+  };
+}
+export {
+  SagepilotChat,
+  SagepilotChatError,
+  SagepilotChatProvider,
+  createAsyncStorageCacheStorage,
+  createKeychainTokenStorage,
+  useSagepilotChat
+};