@memori.ai/memori-react 8.45.2 → 8.45.4

package/src/helpers/nats/getNatsConfig.ts

@@ -1,148 +0,0 @@
-// helpers/nats/getNatsConfig.ts - Fetch NATS connection params (url + token)
-// from the backend, using the same baseUrl already used for /api/tts and /api/stt.
-
-/**
- * Connection parameters returned by `GET /api/nats?sessionId=<uuid>`.
- */
-export interface NatsConfig {
-  /** WebSocket URL of the NATS server (e.g. wss://nats.hz.slnode.net:8080). */
-  url: string;
-  /**
-   * Per-session NATS user JWT. Presented with `jwtAuthenticator` (bearer:
-   * no nkey seed on the client).
-   */
-  token: string;
-  /**
-   * JetStream stream that stores session events. When set, the client consumes
-   * via JetStream instead of core NATS subscribe.
-   */
-  stream?: string;
-  /**
-   * Optional durable consumer name. When omitted, an ordered ephemeral consumer
-   * filtered to the session subject is used.
-   */
-  consumer?: string;
-  /**
-   * Subject to subscribe or filter on. Defaults to `sessions.<sessionId>` when omitted.
-   */
-  subject?: string;
-}
-
-function readStringField(
-  raw: Record<string, unknown>,
-  ...keys: string[]
-): string | undefined {
-  for (const key of keys) {
-    const value = raw[key];
-    if (typeof value === 'string' && value.length > 0) {
-      return value;
-    }
-  }
-  return undefined;
-}
-
-function readBooleanField(
-  raw: Record<string, unknown>,
-  ...keys: string[]
-): boolean | undefined {
-  for (const key of keys) {
-    const value = raw[key];
-    if (typeof value === 'boolean') {
-      return value;
-    }
-  }
-  return undefined;
-}
-
-/**
- * Normalizes raw `/api/nats` payloads (camelCase or snake_case) into {@link NatsConfig}.
- */
-export function parseNatsConfig(raw: Record<string, unknown>): NatsConfig {
-  const url = readStringField(raw, 'url');
-  const token = readStringField(raw, 'token');
-
-  if (!url || !token) {
-    throw new Error('Invalid response from NATS config service');
-  }
-
-  const useJetStream = readBooleanField(raw, 'useJetStream', 'use_jetstream');
-  const stream = readStringField(raw, 'stream', 'streamName', 'stream_name');
-  const consumer = readStringField(
-    raw,
-    'consumer',
-    'consumerName',
-    'consumer_name',
-    'durableName',
-    'durable_name'
-  );
-  const subject = readStringField(
-    raw,
-    'subject',
-    'filterSubject',
-    'filter_subject'
-  );
-
-  if (useJetStream && !stream) {
-    throw new Error('Invalid response from NATS config service: JetStream enabled but stream missing');
-  }
-
-  return {
-    url,
-    token,
-    ...(stream ? { stream } : {}),
-    ...(consumer ? { consumer } : {}),
-    ...(subject ? { subject } : {}),
-  };
-}
-
-/**
- * Fetch the NATS connection config for a given session.
- *
- * Mirrors the error-handling style of the tts/stt helpers: the backend may
- * answer with 400 (sessionId missing), 404 (invalid session) or 500 (NATS
- * config missing). Any non-ok response throws with a descriptive message.
- *
- * @param baseUrl Same baseUrl used for `/api/tts` and `/api/stt`.
- * @param sessionId Current session UUID.
- * @param signal Optional AbortSignal to cancel the request.
- */
-export async function getNatsConfig(
-  baseUrl: string,
-  sessionId: string,
-  signal?: AbortSignal
-): Promise<NatsConfig> {
-  if (!sessionId) {
-    throw new Error('Missing sessionId for NATS config request');
-  }
-
-  const response = await fetch(
-    `${baseUrl}/api/nats?sessionId=${encodeURIComponent(sessionId)}`,
-    { signal }
-  );
-
-  if (!response.ok) {
-    const errorData = await response.json().catch(() => ({} as any));
-
-    switch (response.status) {
-      case 400:
-        throw new Error(
-          errorData.error || 'NATS config error: missing sessionId'
-        );
-      case 404:
-        throw new Error(
-          errorData.error || 'NATS config error: invalid session'
-        );
-      case 500:
-        throw new Error(
-          errorData.error || 'NATS config error: NATS configuration missing'
-        );
-      default:
-        throw new Error(
-          errorData.error || `NATS config error: ${response.status}`
-        );
-    }
-  }
-
-  const data = (await response.json()) as Record<string, unknown>;
-  return parseNatsConfig(data);
-}

package/src/helpers/nats/isSessionExpiredError.test.ts

@@ -1,38 +0,0 @@
-import {
-  isSessionExpiredNatsError,
-  isSessionExpiredNatsResponse,
-} from './isSessionExpiredError';
-
-describe('isSessionExpiredNatsError', () => {
-  it('detects session not found from EnterTextAsync NATS error', () => {
-    expect(
-      isSessionExpiredNatsError({
-        eventType: 'error',
-        errorCode: 'EnterTextAsync Error',
-        errorMessage:
-          'Session with ID "c681a10b-37c1-4783-af3b-ecb592b93036" not found',
-        correlationID: 'f85a6882-92e1-4e18-9fb7-29d3bc06fd7b',
-      })
-    ).toBe(true);
-  });
-
-  it('detects SESSION_EXPIRED result code on dialog response', () => {
-    expect(
-      isSessionExpiredNatsResponse({
-        eventType: 'dialog_text_entered_response',
-        resultCode: -103,
-        correlationID: 'abc',
-      })
-    ).toBe(true);
-  });
-
-  it('ignores unrelated NATS errors', () => {
-    expect(
-      isSessionExpiredNatsError({
-        eventType: 'error',
-        errorCode: 'SomeOtherError',
-        errorMessage: 'Something went wrong',
-      })
-    ).toBe(false);
-  });
-});

package/src/helpers/nats/isSessionExpiredError.ts

@@ -1,51 +0,0 @@
-import type {
-  NatsDialogResponseEvent,
-  NatsErrorEvent,
-} from './useNatsSession';
-
-/** Backend result codes for missing / expired sessions. */
-const SESSION_NOT_FOUND = -101;
-const SESSION_EXPIRED = -103;
-
-const SESSION_NOT_FOUND_MESSAGE =
-  /session\s+with\s+id\s+["']?[^"']+["']?\s+not\s+found/i;
-
-function isExpiredResultCode(resultCode?: number): boolean {
-  return (
-    resultCode === 404 ||
-    resultCode === SESSION_EXPIRED ||
-    resultCode === SESSION_NOT_FOUND
-  );
-}
-
-function isExpiredErrorMessage(message?: string): boolean {
-  if (!message) return false;
-  return SESSION_NOT_FOUND_MESSAGE.test(message);
-}
-
-/** True when a NATS `error` event indicates the active session is gone or expired. */
-export function isSessionExpiredNatsError(event: NatsErrorEvent): boolean {
-  if (isExpiredResultCode(event.errorCode as number | undefined)) {
-    return true;
-  }
-
-  if (typeof event.errorCode === 'string') {
-    const code = event.errorCode.toUpperCase();
-    if (code.includes('SESSION_EXPIRED') || code.includes('SESSION_NOT_FOUND')) {
-      return true;
-    }
-  }
-
-  return isExpiredErrorMessage(event.errorMessage);
-}
-
-/** True when a NATS dialog response reports a missing or expired session. */
-export function isSessionExpiredNatsResponse(
-  event: NatsDialogResponseEvent
-): boolean {
-  if (isExpiredResultCode(event.resultCode)) {
-    return true;
-  }
-
-  return isExpiredErrorMessage(event.resultMessage);
-}

package/src/helpers/nats/useNats.test.tsx

@@ -1,81 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { getNatsConfig } from './getNatsConfig';
-import { useNats } from './useNats';
-import { NatsSessionLifecycle, useNatsSession } from './useNatsSession';
-
-jest.mock('./getNatsConfig', () => ({
-  getNatsConfig: jest.fn(),
-}));
-
-jest.mock('./useNatsSession', () => ({
-  useNatsSession: jest.fn(),
-}));
-
-const mockGetNatsConfig = getNatsConfig as jest.MockedFunction<
-  typeof getNatsConfig
->;
-const mockUseNatsSession = useNatsSession as jest.MockedFunction<
-  typeof useNatsSession
->;
-
-function latestLifecycle(): NatsSessionLifecycle {
-  return mockUseNatsSession.mock.calls.at(-1)?.[3] ?? {};
-}
-
-describe('useNats credential lifecycle', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockGetNatsConfig.mockResolvedValue({
-      url: 'wss://nats.example.test',
-      token: 'fresh-jwt',
-    });
-    Object.defineProperty(document, 'visibilityState', {
-      configurable: true,
-      value: 'visible',
-    });
-  });
-
-  it('refreshes the JWT on resume and catches up after reconnecting', async () => {
-    const onCatchUp = jest.fn();
-    renderHook(() =>
-      useNats({
-        baseUrl: 'https://dashboard.example.test',
-        sessionId: 'session-a',
-        onCatchUp,
-      })
-    );
-
-    await waitFor(() => expect(mockGetNatsConfig).toHaveBeenCalledTimes(1));
-
-    act(() => {
-      (document.dispatchEvent as (event: Event) => boolean)(
-        new Event('visibilitychange')
-      );
-    });
-    await waitFor(() => expect(mockGetNatsConfig).toHaveBeenCalledTimes(2));
-
-    act(() => latestLifecycle().onConnected?.());
-    expect(onCatchUp).toHaveBeenCalledTimes(1);
-  });
-
-  it('refreshes the JWT after an authorization error', async () => {
-    const onCatchUp = jest.fn();
-    renderHook(() =>
-      useNats({
-        baseUrl: 'https://dashboard.example.test',
-        sessionId: 'session-a',
-        onCatchUp,
-      })
-    );
-
-    await waitFor(() => expect(mockGetNatsConfig).toHaveBeenCalledTimes(1));
-
-    act(() => {
-      latestLifecycle().onAuthError?.(new Error('Authorization Violation'));
-    });
-    await waitFor(() => expect(mockGetNatsConfig).toHaveBeenCalledTimes(2));
-
-    act(() => latestLifecycle().onConnected?.());
-    expect(onCatchUp).toHaveBeenCalledTimes(1);
-  });
-});

package/src/helpers/nats/useNats.ts

@@ -1,204 +0,0 @@
-// helpers/nats/useNats.ts - Orchestrates NATS config retrieval + subscription.
-//
-// Additive to the existing HTTP flow: text is sent via `postEnterTextAsync`;
-// this hook *receives* asynchronous events on the session channel (progress /
-// dialog.text_entered_response / error).
-import { useEffect, useRef, useState, useCallback } from 'react';
-import { getNatsConfig, NatsConfig } from './getNatsConfig';
-import {
-  useNatsSession,
-  NatsSessionEvent,
-  NatsProgressEvent,
-  NatsDialogResponseEvent,
-  NatsErrorEvent,
-} from './useNatsSession';
-
-export interface UseNatsOptions {
-  /** Same baseUrl used for /api/tts and /api/stt. */
-  baseUrl: string;
-  /** Current session UUID. Subscription is skipped while undefined. */
-  sessionId?: string;
-  /** `progress` events (e.g. to feed the typing indicator). */
-  onProgress?: (event: NatsProgressEvent) => void;
-  /** `dialog.text_entered_response` events (optional live updates). */
-  onDialogResponse?: (event: NatsDialogResponseEvent) => void;
-  /** `error` events (logging / user notification). */
-  onError?: (event: NatsErrorEvent) => void;
-  /**
-   * Reconcile a pending turn from the engine after a resumed or reauthenticated
-   * subscription is installed.
-   */
-  onCatchUp?: () => void | Promise<void>;
-}
-
-/**
- * Subscribe to the NATS session channel and dispatch decoded events to the
- * provided callbacks. Config is fetched from `/api/nats`; the subscription
- * lifecycle (cleanup on unmount, reconnect on sessionId change) is handled by
- * `useNatsSession`.
- */
-export function useNats({
-  baseUrl,
-  sessionId,
-  onProgress,
-  onDialogResponse,
-  onError,
-  onCatchUp,
-}: UseNatsOptions) {
-  const [config, setConfig] = useState<NatsConfig | null>(null);
-  const [configError, setConfigError] = useState<Error | null>(null);
-
-  // Keep callbacks in refs so the dispatcher identity stays stable.
-  const onProgressRef = useRef(onProgress);
-  const onDialogResponseRef = useRef(onDialogResponse);
-  const onErrorRef = useRef(onError);
-  const onCatchUpRef = useRef(onCatchUp);
-  const abortRef = useRef<AbortController | null>(null);
-  const catchUpAfterConnectRef = useRef(false);
-  const refreshInFlightRef = useRef(false);
-  const lastAuthRefreshRef = useRef(0);
-  useEffect(() => {
-    onProgressRef.current = onProgress;
-    onDialogResponseRef.current = onDialogResponse;
-    onErrorRef.current = onError;
-    onCatchUpRef.current = onCatchUp;
-  }, [onProgress, onDialogResponse, onError, onCatchUp]);
-
-  const refreshConfig = useCallback(
-    async (reason: 'initial' | 'resume' | 'auth') => {
-      if (!sessionId || refreshInFlightRef.current) return;
-      if (reason === 'auth' && Date.now() - lastAuthRefreshRef.current < 5000) {
-        return;
-      }
-
-      refreshInFlightRef.current = true;
-      if (reason === 'auth') lastAuthRefreshRef.current = Date.now();
-      abortRef.current?.abort();
-      const controller = new AbortController();
-      abortRef.current = controller;
-
-      console.info(
-        '[NATS] fetching config from',
-        `${baseUrl}/api/nats`,
-        'for session',
-        sessionId,
-        `(${reason})`
-      );
-      try {
-        const cfg = await getNatsConfig(baseUrl, sessionId, controller.signal);
-        if (!controller.signal.aborted) {
-          catchUpAfterConnectRef.current = reason !== 'initial';
-          console.info('[NATS] config received', {
-            url: cfg.url,
-            jetStream: !!cfg.stream,
-            stream: cfg.stream,
-          });
-          setConfig(cfg);
-          setConfigError(null);
-        }
-      } catch (err: any) {
-        if (!controller.signal.aborted && err?.name !== 'AbortError') {
-          console.error('[NATS] config error', err);
-          setConfig(null);
-          setConfigError(err instanceof Error ? err : new Error(String(err)));
-        }
-      } finally {
-        if (abortRef.current === controller) {
-          abortRef.current = null;
-          refreshInFlightRef.current = false;
-        }
-      }
-    },
-    [baseUrl, sessionId]
-  );
-
-  // Fetch connection config whenever the active session changes.
-  useEffect(() => {
-    if (!sessionId) {
-      console.debug('[NATS] no sessionId, skipping config fetch');
-      setConfig(null);
-      setConfigError(null);
-      return;
-    }
-
-    void refreshConfig('initial');
-    return () => {
-      abortRef.current?.abort();
-      abortRef.current = null;
-      refreshInFlightRef.current = false;
-    };
-  }, [sessionId, refreshConfig]);
-
-  // A suspended browser may lose core NATS messages. Refresh the short-lived
-  // JWT, reconnect, then reconcile the pending turn from the engine.
-  useEffect(() => {
-    if (!sessionId) return;
-
-    const requestResume = () => {
-      if (document.visibilityState === 'visible') {
-        void refreshConfig('resume');
-      }
-    };
-    const onVisibilityChange = () => {
-      if (document.visibilityState === 'visible') requestResume();
-    };
-    const onPageShow = (event: PageTransitionEvent) => {
-      if (event.persisted) requestResume();
-    };
-
-    document.addEventListener('visibilitychange', onVisibilityChange);
-    window.addEventListener('online', requestResume);
-    window.addEventListener('pageshow', onPageShow);
-    return () => {
-      document.removeEventListener('visibilitychange', onVisibilityChange);
-      window.removeEventListener('online', requestResume);
-      window.removeEventListener('pageshow', onPageShow);
-    };
-  }, [sessionId, refreshConfig]);
-
-  const handleMessage = useCallback((event: NatsSessionEvent) => {
-    console.debug('[NATS] dispatching event', { eventType: event.eventType });
-    switch (event.eventType) {
-      case 'progress':
-        onProgressRef.current?.(event);
-        break;
-      case 'dialog_text_entered_response':
-        onDialogResponseRef.current?.(event);
-        break;
-      case 'error':
-        onErrorRef.current?.(event);
-        break;
-      default:
-        console.warn('Unknown NATS event', event);
-    }
-  }, []);
-
-  const handleConnected = useCallback(() => {
-    if (!catchUpAfterConnectRef.current) return;
-    catchUpAfterConnectRef.current = false;
-    void onCatchUpRef.current?.();
-  }, []);
-
-  const handleAuthError = useCallback(
-    (error: Error) => {
-      console.warn(
-        '[NATS] JWT rejected or expired; refreshing credentials',
-        error
-      );
-      void refreshConfig('auth');
-    },
-    [refreshConfig]
-  );
-
-  useNatsSession(sessionId, config ?? undefined, handleMessage, {
-    onConnected: handleConnected,
-    onAuthError: handleAuthError,
-  });
-
-  return {
-    /** True once connection config has been retrieved. */
-    connected: !!config,
-    /** Last config-retrieval error, if any. */
-    configError,
-  };
-}

package/src/helpers/nats/useNatsSession.test.ts

@@ -1,16 +0,0 @@
-import { AuthorizationError } from '@nats-io/nats-core';
-import { isNatsAuthError } from './useNatsSession';
-
-describe('isNatsAuthError', () => {
-  it('recognizes typed NATS authorization failures', () => {
-    expect(isNatsAuthError(new AuthorizationError('test'))).toBe(true);
-  });
-
-  it('recognizes the server authorization violation message', () => {
-    expect(isNatsAuthError(new Error('Authorization Violation'))).toBe(true);
-  });
-
-  it('does not classify unrelated connection failures as auth failures', () => {
-    expect(isNatsAuthError(new Error('connection refused'))).toBe(false);
-  });
-});