@tipsy-studio/sdk 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -1,2 +1,165 @@
+declare const TIPSY_BRIDGE_PROTOCOL = "tipsy-bridge-v1";
+declare const TIPSY_INIT_RETRY_MS = 500;
+declare const RESPOND_METHOD = "sdk.respond";
+type TipsyRole = "system" | "user" | "assistant";
+type TipsyMessage = {
+    role: TipsyRole;
+    content: string;
+};
+type TipsyUsage = {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+};
+type TipsyTextResponseFormat = {
+    type: "text";
+};
+type TipsyJsonSchemaResponseFormat = {
+    type: "json_schema";
+    name: string;
+    schema: Record<string, unknown>;
+};
+type TipsyRespondResponseFormat = TipsyTextResponseFormat | TipsyJsonSchemaResponseFormat;
+type TipsyRespondRequestBase = {
+    messages: TipsyMessage[];
+    model_id?: string | null;
+    response_format: TipsyRespondResponseFormat;
+};
+type TipsyRespondStreamRequest = TipsyRespondRequestBase & {
+    stream: true;
+};
+type TipsyRespondNonStreamRequest = TipsyRespondRequestBase & {
+    stream: false;
+};
+type TipsyRespondRequest = TipsyRespondStreamRequest | TipsyRespondNonStreamRequest;
+type TipsyRespondEnvelope<T = unknown> = {
+    code: number;
+    msg: string;
+    trace_id: string;
+    data: {
+        message_id: string;
+        result: T;
+        response_format: TipsyTextResponseFormat | {
+            type: "json_schema";
+            name: string;
+        };
+        usage: TipsyUsage;
+    };
+};
+type TipsyRespondTextStreamEvent = {
+    type: "delta";
+    delta: string;
+};
+type TipsyRespondJsonStreamEvent<T = unknown> = {
+    type: "delta";
+    snapshot: Partial<T> | T;
+};
+type TipsyRespondMetaEvent = {
+    type: "meta";
+    message_id: string;
+    usage: TipsyUsage;
+    trace_id: string;
+};
+type TipsyRespondStreamEvent<T = unknown> = TipsyRespondTextStreamEvent | TipsyRespondJsonStreamEvent<T> | TipsyRespondMetaEvent;
+type TipsyRespondResult<T = unknown> = {
+    message_id: string;
+    result: T;
+    response_format: TipsyTextResponseFormat | {
+        type: "json_schema";
+        name: string;
+    };
+};
+type TipsyBridgeErrorCode = "UNAUTHORIZED" | "BAD_REQUEST" | "NETWORK_ERROR" | "STREAM_PARSE_ERROR" | "ORIGIN_MISMATCH" | "UNSUPPORTED_METHOD" | "INTERNAL_ERROR";
+type TipsyBridgeError = {
+    code: TipsyBridgeErrorCode;
+    message: string;
+};
+type TipsyBridgeRequestMap = {
+    [RESPOND_METHOD]: TipsyRespondRequest;
+};
+type TipsyBridgeStreamMap = {
+    [RESPOND_METHOD]: TipsyRespondStreamEvent;
+};
+type TipsyBridgeResponseMap = {
+    [RESPOND_METHOD]: TipsyRespondEnvelope | TipsyRespondResult;
+};
+type TipsyInitMessage = {
+    protocol: typeof TIPSY_BRIDGE_PROTOCOL;
+    type: "tipsy:init";
+};
+type TipsyInitAckMessage = {
+    protocol: typeof TIPSY_BRIDGE_PROTOCOL;
+    type: "tipsy:init:ack";
+};
+type TipsyRequestMessage<M extends keyof TipsyBridgeRequestMap> = {
+    protocol: typeof TIPSY_BRIDGE_PROTOCOL;
+    type: "tipsy:request";
+    requestId: string;
+    method: M;
+    params: TipsyBridgeRequestMap[M];
+};
+type TipsyStreamMessage<M extends keyof TipsyBridgeStreamMap> = {
+    protocol: typeof TIPSY_BRIDGE_PROTOCOL;
+    type: "tipsy:stream";
+    requestId: string;
+    payload: {
+        method: M;
+        event: TipsyBridgeStreamMap[M];
+    };
+};
+type TipsyResponseMessage<M extends keyof TipsyBridgeResponseMap> = {
+    protocol: typeof TIPSY_BRIDGE_PROTOCOL;
+    type: "tipsy:response";
+    requestId: string;
+    payload: {
+        method: M;
+        result: TipsyBridgeResponseMap[M];
+    };
+};
+type TipsyErrorMessage = {
+    protocol: typeof TIPSY_BRIDGE_PROTOCOL;
+    type: "tipsy:error";
+    requestId?: string;
+    error: TipsyBridgeError;
+};
+type TipsyAbortMessage = {
+    protocol: typeof TIPSY_BRIDGE_PROTOCOL;
+    type: "tipsy:abort";
+    requestId: string;
+};
+type TipsyBridgeMessage = TipsyInitMessage | TipsyInitAckMessage | TipsyRequestMessage<keyof TipsyBridgeRequestMap> | TipsyStreamMessage<keyof TipsyBridgeStreamMap> | TipsyResponseMessage<keyof TipsyBridgeResponseMap> | TipsyErrorMessage | TipsyAbortMessage;
+type TipsyRequestController<M extends keyof TipsyBridgeRequestMap> = {
+    signal?: AbortSignal;
+    onEvent?: (event: TipsyBridgeStreamMap[M]) => void;
+};
+type TipsyRespondController<T = unknown> = {
+    signal?: AbortSignal;
+    onEvent?: (event: TipsyRespondStreamEvent<T>) => void;
+};
+declare class TipsyBridgeClientError extends Error {
+    code: TipsyBridgeErrorCode;
+    constructor(error: TipsyBridgeError);
+}
+declare function getParentOriginFromReferrer(): string | null;
+declare function normalizeTargetOrigin(value?: string): string;
+declare function isBridgeMessage(value: unknown): value is TipsyBridgeMessage;
+declare function createRequestId(): string;
 
-export {  }
+type TipsyStudioClientOptions = {
+    targetOrigin?: string;
+    sourceWindow?: Window;
+    targetWindow?: Window;
+};
+type TipsyStudioClient = {
+    isReady: () => boolean;
+    subscribe: (listener: (isReady: boolean) => void) => () => void;
+    waitForReady: (signal?: AbortSignal) => Promise<void>;
+    call: <M extends keyof TipsyBridgeRequestMap>(method: M, params: TipsyBridgeRequestMap[M], controller?: TipsyRequestController<M>) => Promise<TipsyBridgeResponseMap[M]>;
+    respond<T = string>(request: TipsyRespondNonStreamRequest, controller?: TipsyRespondController<T>): Promise<TipsyRespondEnvelope<T>>;
+    respond<T = string>(request: TipsyRespondStreamRequest, controller?: TipsyRespondController<T>): Promise<TipsyRespondResult<T>>;
+    respond<T = string>(request: TipsyRespondRequest, controller?: TipsyRespondController<T>): Promise<TipsyRespondEnvelope<T> | TipsyRespondResult<T>>;
+    destroy: () => void;
+};
+declare function createTipsyStudioClient(options?: TipsyStudioClientOptions): TipsyStudioClient;
+
+export { RESPOND_METHOD, TIPSY_BRIDGE_PROTOCOL, TIPSY_INIT_RETRY_MS, type TipsyAbortMessage, TipsyBridgeClientError, type TipsyBridgeError, type TipsyBridgeErrorCode, type TipsyBridgeMessage, type TipsyBridgeRequestMap, type TipsyBridgeResponseMap, type TipsyBridgeStreamMap, type TipsyJsonSchemaResponseFormat, type TipsyMessage, type TipsyRequestController, type TipsyRequestMessage, type TipsyRespondController, type TipsyRespondEnvelope, type TipsyRespondMetaEvent, type TipsyRespondNonStreamRequest, type TipsyRespondRequest, type TipsyRespondResponseFormat, type TipsyRespondResult, type TipsyRespondStreamEvent, type TipsyRespondStreamRequest, type TipsyRole, type TipsyStudioClient, type TipsyStudioClientOptions, type TipsyTextResponseFormat, type TipsyUsage, createRequestId, createTipsyStudioClient, getParentOriginFromReferrer, isBridgeMessage, normalizeTargetOrigin };

package/dist/index.js

@@ -1,3 +1,3 @@
-
+export { RESPOND_METHOD, TIPSY_BRIDGE_PROTOCOL, TIPSY_INIT_RETRY_MS, TipsyBridgeClientError, createRequestId, createTipsyStudioClient, getParentOriginFromReferrer, isBridgeMessage, normalizeTargetOrigin } from './chunk-NLCN4YRK.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/react.cjs

@@ -7,7 +7,7 @@ var react = require('react');
 // src/bridge.ts
 var TIPSY_BRIDGE_PROTOCOL = "tipsy-bridge-v1";
 var TIPSY_INIT_RETRY_MS = 500;
-var CHAT_COMPLETIONS_METHOD = "chat.completions";
+var RESPOND_METHOD = "sdk.respond";
 var TipsyBridgeClientError = class extends Error {
   constructor(error) {
     super(error.message);
@@ -57,171 +57,319 @@ function createRequestId() {
   return `tipsy_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
 }
 
-// src/react.ts
-var TipsyStudioContext = react.createContext(null);
-function TipsyStudioProvider({
-  children,
-  targetOrigin
-}) {
-  const resolvedTargetOrigin = react.useMemo(
-    () => normalizeTargetOrigin(targetOrigin),
-    [targetOrigin]
-  );
-  const [isReady, setIsReady] = react.useState(false);
-  const pendingRef = react.useRef(/* @__PURE__ */ new Map());
-  const readyRef = react.useRef(false);
-  const targetOriginRef = react.useRef(resolvedTargetOrigin);
-  react.useEffect(() => {
-    targetOriginRef.current = resolvedTargetOrigin;
-  }, [resolvedTargetOrigin]);
-  react.useEffect(() => {
-    if (typeof window === "undefined") {
-      return void 0;
+// src/client.ts
+var TIPSY_READY_WAIT_RETRY_COUNT = 6;
+function createTipsyStudioClient(options = {}) {
+  const sourceWindow = options.sourceWindow ?? (typeof window !== "undefined" ? window : void 0);
+  const targetWindow = options.targetWindow ?? (sourceWindow && sourceWindow.parent !== sourceWindow ? sourceWindow.parent : void 0);
+  const targetOrigin = normalizeTargetOrigin(options.targetOrigin);
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const readyWaiters = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  let isDestroyed = false;
+  let isConnected = false;
+  let isReady = false;
+  let initIntervalId = null;
+  const emitReadyChange = (nextReady) => {
+    if (isReady === nextReady) {
+      return;
     }
-    let cancelled = false;
-    const rejectPending = (error) => {
-      const pendingRequests = Array.from(pendingRef.current.values());
-      pendingRef.current.clear();
-      for (const pending of pendingRequests) {
-        pending.reject(new TipsyBridgeClientError(error));
-      }
-    };
-    const postInit = () => {
-      if (cancelled || readyRef.current || window.parent === window) {
+    isReady = nextReady;
+    for (const listener of listeners) {
+      listener(isReady);
+    }
+  };
+  const resolveReadyWaiters = () => {
+    const waiters = Array.from(readyWaiters.values());
+    readyWaiters.clear();
+    for (const resolve of waiters) {
+      resolve();
+    }
+  };
+  const rejectPending = (error) => {
+    const requests = Array.from(pendingRequests.values());
+    pendingRequests.clear();
+    for (const pending of requests) {
+      pending.cleanupAbortListener?.();
+      pending.reject(new TipsyBridgeClientError(error));
+    }
+  };
+  const postMessageToTarget = (message) => {
+    targetWindow?.postMessage(message, targetOrigin);
+  };
+  const postInit = () => {
+    if (isDestroyed || isReady || !targetWindow) {
+      return;
+    }
+    postMessageToTarget({
+      protocol: TIPSY_BRIDGE_PROTOCOL,
+      type: "tipsy:init"
+    });
+  };
+  const handleMessage = (event) => {
+    if (isDestroyed || event.source !== targetWindow) {
+      return;
+    }
+    if (targetOrigin !== "*" && event.origin !== targetOrigin) {
+      return;
+    }
+    if (!isBridgeMessage(event.data)) {
+      return;
+    }
+    if (event.data.type === "tipsy:init:ack") {
+      emitReadyChange(true);
+      resolveReadyWaiters();
+      return;
+    }
+    if (event.data.type === "tipsy:error") {
+      if (!event.data.requestId) {
         return;
       }
-      const initMessage = {
-        protocol: TIPSY_BRIDGE_PROTOCOL,
-        type: "tipsy:init"
-      };
-      window.parent.postMessage(initMessage, targetOriginRef.current);
-    };
-    const intervalId = window.setInterval(postInit, TIPSY_INIT_RETRY_MS);
-    postInit();
-    const handleMessage = (event) => {
-      if (window.parent === window || event.source !== window.parent) {
+      const pending = pendingRequests.get(event.data.requestId);
+      if (!pending) {
         return;
       }
-      if (targetOriginRef.current !== "*" && event.origin !== targetOriginRef.current) {
+      pendingRequests.delete(event.data.requestId);
+      pending.cleanupAbortListener?.();
+      pending.reject(new TipsyBridgeClientError(event.data.error));
+      return;
+    }
+    if (event.data.type === "tipsy:stream") {
+      const pending = pendingRequests.get(event.data.requestId);
+      if (!pending || pending.method !== event.data.payload.method) {
         return;
       }
-      if (!isBridgeMessage(event.data)) {
+      pending.onEvent?.(event.data.payload.event);
+      return;
+    }
+    if (event.data.type === "tipsy:response") {
+      const pending = pendingRequests.get(event.data.requestId);
+      if (!pending || pending.method !== event.data.payload.method) {
         return;
       }
-      if (event.data.type === "tipsy:init:ack") {
-        readyRef.current = true;
-        setIsReady(true);
-        return;
+      pendingRequests.delete(event.data.requestId);
+      pending.cleanupAbortListener?.();
+      pending.resolve(event.data.payload.result);
+    }
+  };
+  const ensureConnected = () => {
+    if (isDestroyed || isConnected || !sourceWindow) {
+      return;
+    }
+    sourceWindow.addEventListener("message", handleMessage);
+    initIntervalId = sourceWindow.setInterval(postInit, TIPSY_INIT_RETRY_MS);
+    isConnected = true;
+    postInit();
+  };
+  const ensureBridgeAvailable = () => {
+    if (!sourceWindow || !targetWindow) {
+      throw new TipsyBridgeClientError({
+        code: "NETWORK_ERROR",
+        message: "Tipsy bridge is only available inside an iframe."
+      });
+    }
+  };
+  const waitForReady = async (signal) => {
+    if (isDestroyed) {
+      throw new TipsyBridgeClientError({
+        code: "NETWORK_ERROR",
+        message: "Tipsy bridge was disconnected."
+      });
+    }
+    ensureBridgeAvailable();
+    ensureConnected();
+    const activeSourceWindow = sourceWindow;
+    if (!activeSourceWindow) {
+      throw new TipsyBridgeClientError({
+        code: "NETWORK_ERROR",
+        message: "Tipsy bridge is only available inside an iframe."
+      });
+    }
+    if (isReady) {
+      return;
+    }
+    for (let attempt = 0; attempt < TIPSY_READY_WAIT_RETRY_COUNT; attempt += 1) {
+      if (signal?.aborted) {
+        throw new DOMException("The operation was aborted.", "AbortError");
       }
-      if (event.data.type === "tipsy:error") {
-        if (!event.data.requestId) {
-          return;
-        }
-        const pending = pendingRef.current.get(event.data.requestId);
-        if (!pending) {
-          return;
-        }
-        pendingRef.current.delete(event.data.requestId);
-        pending.reject(new TipsyBridgeClientError(event.data.error));
+      postInit();
+      await new Promise((resolve, reject) => {
+        let timeoutId = 0;
+        const handleReady = () => {
+          activeSourceWindow.clearTimeout(timeoutId);
+          signal?.removeEventListener("abort", handleAbort);
+          readyWaiters.delete(handleReady);
+          resolve();
+        };
+        const handleAbort = () => {
+          activeSourceWindow.clearTimeout(timeoutId);
+          readyWaiters.delete(handleReady);
+          signal?.removeEventListener("abort", handleAbort);
+          reject(new DOMException("The operation was aborted.", "AbortError"));
+        };
+        readyWaiters.add(handleReady);
+        timeoutId = activeSourceWindow.setTimeout(() => {
+          readyWaiters.delete(handleReady);
+          signal?.removeEventListener("abort", handleAbort);
+          resolve();
+        }, TIPSY_INIT_RETRY_MS);
+        signal?.addEventListener("abort", handleAbort, { once: true });
+      });
+      if (isReady) {
         return;
       }
-      if (event.data.type === "tipsy:stream") {
-        const pending = pendingRef.current.get(event.data.requestId);
-        if (!pending || pending.method !== CHAT_COMPLETIONS_METHOD) {
-          return;
+    }
+    throw new TipsyBridgeClientError({
+      code: "NETWORK_ERROR",
+      message: "Tipsy bridge is not ready."
+    });
+  };
+  function respond(request, controller) {
+    return client.call(RESPOND_METHOD, request, {
+      signal: controller?.signal,
+      onEvent: controller?.onEvent
+    });
+  }
+  const client = {
+    isReady: () => isReady,
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(isReady);
+      ensureConnected();
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    async waitForReady(signal) {
+      await waitForReady(signal);
+    },
+    async call(method, params, controller) {
+      if (isDestroyed) {
+        throw new TipsyBridgeClientError({
+          code: "NETWORK_ERROR",
+          message: "Tipsy bridge was disconnected."
+        });
+      }
+      await waitForReady(controller?.signal);
+      const requestId = createRequestId();
+      return await new Promise(
+        (resolve, reject) => {
+          const pending = {
+            method,
+            resolve: (value) => resolve(value),
+            reject,
+            onEvent: controller?.onEvent
+          };
+          pendingRequests.set(requestId, pending);
+          const abortSignal = controller?.signal;
+          const handleAbort = () => {
+            if (!pendingRequests.has(requestId)) {
+              return;
+            }
+            pendingRequests.delete(requestId);
+            pending.cleanupAbortListener?.();
+            postMessageToTarget({
+              protocol: TIPSY_BRIDGE_PROTOCOL,
+              type: "tipsy:abort",
+              requestId
+            });
+            reject(new DOMException("The operation was aborted.", "AbortError"));
+          };
+          pending.cleanupAbortListener = () => {
+            abortSignal?.removeEventListener("abort", handleAbort);
+          };
+          if (abortSignal?.aborted) {
+            handleAbort();
+            return;
+          }
+          abortSignal?.addEventListener("abort", handleAbort, { once: true });
+          postMessageToTarget({
+            protocol: TIPSY_BRIDGE_PROTOCOL,
+            type: "tipsy:request",
+            requestId,
+            method,
+            params
+          });
         }
-        pending.onData?.(event.data.payload);
+      );
+    },
+    respond,
+    destroy() {
+      if (isDestroyed) {
         return;
       }
-      if (event.data.type === "tipsy:response") {
-        const pending = pendingRef.current.get(event.data.requestId);
-        if (!pending) {
-          return;
+      isDestroyed = true;
+      resolveReadyWaiters();
+      emitReadyChange(false);
+      listeners.clear();
+      if (isConnected && sourceWindow) {
+        if (initIntervalId !== null) {
+          sourceWindow.clearInterval(initIntervalId);
         }
-        pendingRef.current.delete(event.data.requestId);
-        pending.onComplete?.(event.data.payload);
-        pending.resolve(event.data.payload);
+        sourceWindow.removeEventListener("message", handleMessage);
       }
-    };
-    window.addEventListener("message", handleMessage);
-    return () => {
-      cancelled = true;
-      readyRef.current = false;
-      setIsReady(false);
-      window.clearInterval(intervalId);
-      window.removeEventListener("message", handleMessage);
+      initIntervalId = null;
+      isConnected = false;
       rejectPending({
         code: "NETWORK_ERROR",
         message: "Tipsy bridge was disconnected."
       });
+    }
+  };
+  return client;
+}
+
+// src/react.ts
+var TipsyStudioContext = react.createContext(null);
+function TipsyStudioProvider({
+  children,
+  targetOrigin
+}) {
+  const resolvedTargetOrigin = react.useMemo(
+    () => normalizeTargetOrigin(targetOrigin),
+    [targetOrigin]
+  );
+  const [isReady, setIsReady] = react.useState(false);
+  const [client, setClient] = react.useState(null);
+  react.useEffect(() => {
+    const nextClient = createTipsyStudioClient({ targetOrigin });
+    setClient(nextClient);
+    setIsReady(nextClient.isReady());
+    const unsubscribe = nextClient.subscribe((nextIsReady) => {
+      setIsReady(nextIsReady);
+    });
+    return () => {
+      unsubscribe();
+      nextClient.destroy();
+      setClient(
+        (currentClient) => currentClient === nextClient ? null : currentClient
+      );
+      setIsReady(false);
     };
-  }, []);
+  }, [targetOrigin]);
   const contextValue = react.useMemo(() => {
+    const notReadyError = new TipsyBridgeClientError({
+      code: "NETWORK_ERROR",
+      message: "Tipsy bridge is not ready."
+    });
+    const respond = ((request, controller) => {
+      if (!client) {
+        return Promise.reject(notReadyError);
+      }
+      return client.respond(request, controller);
+    });
     return {
       isReady,
       targetOrigin: resolvedTargetOrigin,
-      call(method, payload, controller) {
-        if (typeof window === "undefined" || window.parent === window) {
-          return Promise.reject(
-            new TipsyBridgeClientError({
-              code: "NETWORK_ERROR",
-              message: "Tipsy bridge is only available inside an iframe."
-            })
-          );
+      call(method, params, controller) {
+        if (!client) {
+          return Promise.reject(notReadyError);
         }
-        if (!readyRef.current) {
-          return Promise.reject(
-            new TipsyBridgeClientError({
-              code: "NETWORK_ERROR",
-              message: "Tipsy bridge is not ready."
-            })
-          );
-        }
-        const requestId = createRequestId();
-        return new Promise(
-          (resolve, reject) => {
-            const pending = {
-              method,
-              resolve: (value) => resolve(value),
-              reject,
-              onData: method === CHAT_COMPLETIONS_METHOD ? controller?.onData : void 0,
-              onComplete: method === CHAT_COMPLETIONS_METHOD ? controller?.onComplete : void 0
-            };
-            pendingRef.current.set(requestId, pending);
-            const abortSignal = controller?.signal;
-            const handleAbort = () => {
-              if (!pendingRef.current.has(requestId)) {
-                return;
-              }
-              pendingRef.current.delete(requestId);
-              const abortMessage = {
-                protocol: TIPSY_BRIDGE_PROTOCOL,
-                type: "tipsy:abort",
-                requestId
-              };
-              window.parent.postMessage(abortMessage, targetOriginRef.current);
-              reject(
-                new DOMException("The operation was aborted.", "AbortError")
-              );
-            };
-            if (abortSignal?.aborted) {
-              handleAbort();
-              return;
-            }
-            abortSignal?.addEventListener("abort", handleAbort, { once: true });
-            const requestMessage = {
-              protocol: TIPSY_BRIDGE_PROTOCOL,
-              type: "tipsy:request",
-              requestId,
-              method,
-              payload
-            };
-            window.parent.postMessage(requestMessage, targetOriginRef.current);
-          }
-        );
-      }
+        return client.call(method, params, controller);
+      },
+      respond
     };
-  }, [isReady, resolvedTargetOrigin]);
+  }, [client, isReady, resolvedTargetOrigin]);
   return react.createElement(
     TipsyStudioContext.Provider,
     { value: contextValue },
@@ -235,22 +383,17 @@ function useTipsyStudio() {
   }
   return context;
 }
-function useTipsyChat() {
-  const studio = useTipsyStudio();
-  return react.useMemo(() => {
-    return {
-      completions(input, controller) {
-        return studio.call(CHAT_COMPLETIONS_METHOD, input, controller);
-      }
-    };
-  }, [studio]);
-}
 
-exports.CHAT_COMPLETIONS_METHOD = CHAT_COMPLETIONS_METHOD;
+exports.RESPOND_METHOD = RESPOND_METHOD;
 exports.TIPSY_BRIDGE_PROTOCOL = TIPSY_BRIDGE_PROTOCOL;
+exports.TIPSY_INIT_RETRY_MS = TIPSY_INIT_RETRY_MS;
 exports.TipsyBridgeClientError = TipsyBridgeClientError;
 exports.TipsyStudioProvider = TipsyStudioProvider;
-exports.useTipsyChat = useTipsyChat;
+exports.createRequestId = createRequestId;
+exports.createTipsyStudioClient = createTipsyStudioClient;
+exports.getParentOriginFromReferrer = getParentOriginFromReferrer;
+exports.isBridgeMessage = isBridgeMessage;
+exports.normalizeTargetOrigin = normalizeTargetOrigin;
 exports.useTipsyStudio = useTipsyStudio;
 //# sourceMappingURL=react.cjs.map
 //# sourceMappingURL=react.cjs.map