@elevasis/ui 2.49.0 → 2.50.0

package/dist/features/public-agent-chat/index.d.ts

@@ -0,0 +1,161 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _tanstack_react_query from '@tanstack/react-query';
+
+type MessageType = MessageEvent['type'];
+interface ChatMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    messageType: MessageType;
+    text: string;
+    metadata?: MessageEvent;
+    turnNumber: number;
+    messageIndex?: number;
+    createdAt: Date;
+}
+/** Token usage data sent with turn:complete WebSocket events */
+interface SessionTokenUsage {
+    /** Tokens consumed by this turn's input */
+    turnInputTokens: number;
+    /** Tokens generated by this turn's output */
+    turnOutputTokens: number;
+    /** Total tokens for this turn (turnInputTokens + turnOutputTokens) */
+    turnTotalTokens: number;
+    /** Cumulative input tokens across all turns in this session */
+    cumulativeInputTokens: number;
+    /** Cumulative output tokens across all turns in this session */
+    cumulativeOutputTokens: number;
+    /** The model's context window size for this session (e.g., 200K) */
+    contextWindowSize: number;
+}
+
+/**
+ * Base Execution Engine type definitions
+ * Core types shared across all Execution Engine resources
+ */
+
+/**
+ * Unified message event type - covers all message types in sessions
+ * Replaces separate SessionTurnMessages and AgentActivityEvent mechanisms
+ */
+/**
+ * Structured action metadata attached to assistant messages.
+ * Frontend reads this instead of parsing text prefixes.
+ */
+type AssistantAction = {
+    kind: 'navigate';
+    path: string;
+    reason: string;
+} | {
+    kind: 'update_filters';
+    timeRange: string | null;
+    statusFilter: string | null;
+    searchQuery: string | null;
+};
+type MessageEvent = {
+    type: 'user_message';
+    text: string;
+} | {
+    type: 'assistant_message';
+    text: string;
+    _action?: AssistantAction;
+} | {
+    type: 'agent:started';
+} | {
+    type: 'agent:completed';
+} | {
+    type: 'agent:error';
+    error: string;
+} | {
+    type: 'agent:reasoning';
+    iteration: number;
+    reasoning: string;
+} | {
+    type: 'agent:tool_call';
+    toolName: string;
+    args: Record<string, unknown>;
+} | {
+    type: 'agent:tool_result';
+    toolName: string;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+};
+
+interface PublicAgentChatGrant {
+    slug: string;
+    resourceId: string;
+    mode: 'public' | 'code' | string;
+    requiresCode: boolean;
+    branding?: unknown;
+    captureFields?: unknown;
+    maxTurnsPerSession?: number;
+}
+interface PublicAgentChatMetadataResponse {
+    grant: PublicAgentChatGrant;
+}
+interface PublicAgentChatAuthorizeResponse {
+    capabilityToken: string;
+    expiresAt: string;
+    grant: PublicAgentChatGrant;
+}
+interface PublicAgentChatSessionResponse {
+    sessionId: string;
+    resourceId: string;
+    turnCount: number;
+    isEnded: boolean;
+    title: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface PublicAgentChatMessagesResponse {
+    sessionId: string;
+    messages: Array<Omit<ChatMessage, 'createdAt'> & {
+        createdAt?: string;
+    }>;
+    limit: number;
+    cursor: number | null;
+    nextCursor: number | null;
+    total: number;
+    hasMore: boolean;
+}
+interface PublicAgentChatConnectionState {
+    isConnected: boolean;
+    isProcessing: boolean;
+    error: string | null;
+}
+
+interface PublicAgentChatProps {
+    apiUrl: string;
+    slug: string;
+    visitorId?: string;
+    metadata?: Record<string, unknown>;
+    title?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    onSessionReady?: (session: PublicAgentChatSessionResponse) => void;
+}
+declare function PublicAgentChat({ apiUrl, slug, visitorId, metadata, title, className, style, onSessionReady }: PublicAgentChatProps): react_jsx_runtime.JSX.Element;
+
+declare function usePublicAgentChatMessages(apiUrl: string, sessionId: string | null, capabilityToken: string | null): _tanstack_react_query.UseQueryResult<ChatMessage[], Error>;
+
+interface WebSocketState {
+    isConnected: boolean;
+    isProcessing: boolean;
+    error: string | null;
+}
+
+declare function usePublicAgentChatWebSocket(sessionId: string | null, apiUrl: string, capabilityToken: string | null): {
+    messages: ChatMessage[];
+    state: WebSocketState;
+    sendMessage: (text: string) => void;
+    clearError: () => void;
+    lastTokenUsage: SessionTokenUsage | null;
+};
+
+declare const publicAgentChatKeys: {
+    all: readonly ["public-agent-chat"];
+    messages: (sessionId: string) => readonly ["public-agent-chat", "messages", string];
+};
+
+export { PublicAgentChat, publicAgentChatKeys, usePublicAgentChatMessages, usePublicAgentChatWebSocket };
+export type { PublicAgentChatAuthorizeResponse, PublicAgentChatConnectionState, PublicAgentChatGrant, PublicAgentChatMessagesResponse, PublicAgentChatMetadataResponse, PublicAgentChatProps, PublicAgentChatSessionResponse };

package/dist/features/public-agent-chat/index.js

@@ -0,0 +1,413 @@
+import { WebSocketSessionTurnSchema } from '../../chunk-EJL4U7OZ.js';
+import { ChatInterface } from '../../chunk-GUKY77FJ.js';
+import { WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, validateTokenLimit, TOKEN_LIMITS } from '../../chunk-FVOMKZ7S.js';
+import '../../chunk-TVTSASST.js';
+import '../../chunk-I2KLQ2HA.js';
+import { Center, Loader, Paper, Stack, Group, Title, Alert, PasswordInput, Button, Text } from '@mantine/core';
+import { IconLock, IconAlertCircle, IconSend } from '@tabler/icons-react';
+import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/features/public-agent-chat/queryKeys.ts
+var publicAgentChatKeys = {
+  all: ["public-agent-chat"],
+  messages: (sessionId) => [...publicAgentChatKeys.all, "messages", sessionId]
+};
+
+// src/features/public-agent-chat/usePublicAgentChatMessages.ts
+function usePublicAgentChatMessages(apiUrl, sessionId, capabilityToken) {
+  return useQuery({
+    queryKey: [...publicAgentChatKeys.messages(sessionId ?? "pending"), apiUrl, capabilityToken],
+    queryFn: async () => {
+      if (!sessionId || !capabilityToken) return [];
+      const response = await fetch(`${apiUrl}/api/public/agent-chat/sessions/${sessionId}/messages`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${capabilityToken}`
+        }
+      });
+      if (!response.ok) {
+        throw new Error("Failed to load public agent chat messages");
+      }
+      const payload = await response.json();
+      return payload.messages.map(
+        (message) => ({
+          ...message,
+          createdAt: message.createdAt ? new Date(message.createdAt) : /* @__PURE__ */ new Date()
+        })
+      );
+    },
+    enabled: !!apiUrl && !!sessionId && !!capabilityToken,
+    staleTime: 0
+  });
+}
+
+// src/hooks/sessions/sessionWebSocketUtils.ts
+function formatMessageEvent(event) {
+  switch (event.type) {
+    case "user_message":
+      return event.text;
+    case "assistant_message":
+      return event.text;
+    case "agent:started":
+      return "Agent started reasoning";
+    case "agent:reasoning":
+      return `Reasoning (Iteration ${event.iteration})`;
+    case "agent:tool_call":
+      return `Tool: ${event.toolName}`;
+    case "agent:tool_result":
+      return event.success ? "Tool Result" : "Tool Result (Failed)";
+    case "agent:completed":
+      return "Agent completed";
+    case "agent:error":
+      return `Agent error: ${event.error}`;
+  }
+}
+function getWebSocketBaseUrl(apiUrl) {
+  const url = new URL(apiUrl);
+  const protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return `${protocol}//${url.host}`;
+}
+
+// src/features/public-agent-chat/usePublicAgentChatWebSocket.ts
+function usePublicAgentChatWebSocket(sessionId, apiUrl, capabilityToken) {
+  const [messages, setMessages] = useState([]);
+  const [state, setState] = useState({
+    isConnected: false,
+    isProcessing: false,
+    error: null
+  });
+  const [lastTokenUsage, setLastTokenUsage] = useState(null);
+  const wsRef = useRef(null);
+  const retryCountRef = useRef(0);
+  const reconnectTimeoutRef = useRef(null);
+  const queryClient = useQueryClient();
+  const sessionIdRef = useRef(sessionId);
+  sessionIdRef.current = sessionId;
+  const capabilityTokenRef = useRef(capabilityToken);
+  capabilityTokenRef.current = capabilityToken;
+  const queryClientRef = useRef(queryClient);
+  queryClientRef.current = queryClient;
+  const connect = useCallback(() => {
+    const currentSessionId = sessionIdRef.current;
+    const currentCapabilityToken = capabilityTokenRef.current;
+    if (!currentSessionId || !currentCapabilityToken) {
+      return;
+    }
+    if (wsRef.current?.readyState === WebSocket.OPEN || wsRef.current?.readyState === WebSocket.CONNECTING) {
+      return;
+    }
+    const wsUrl = `${getWebSocketBaseUrl(apiUrl)}/api/public/ws/agent-chat/${currentSessionId}?token=${encodeURIComponent(currentCapabilityToken)}`;
+    const ws = new WebSocket(wsUrl);
+    ws.onopen = () => {
+      setState((prev) => ({ ...prev, isConnected: true, error: null }));
+      retryCountRef.current = 0;
+      queryClientRef.current.invalidateQueries({
+        queryKey: publicAgentChatKeys.messages(currentSessionId)
+      });
+    };
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type && data.type !== "turn:complete" && data.type !== "error") {
+          const tempMessage = {
+            id: `temp-${Date.now()}`,
+            role: data.type === "user_message" ? "user" : "assistant",
+            messageType: data.type,
+            text: formatMessageEvent(data),
+            metadata: data.type.startsWith("agent:") ? data : void 0,
+            turnNumber: 999999,
+            messageIndex: Date.now(),
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          setMessages((prev) => [...prev, tempMessage]);
+        } else if (data.type === "turn:complete") {
+          if (data.tokenUsage) {
+            setLastTokenUsage(data.tokenUsage);
+          }
+          setState((prev) => ({ ...prev, isProcessing: false }));
+          queryClientRef.current.invalidateQueries({
+            queryKey: publicAgentChatKeys.messages(currentSessionId)
+          });
+        } else if (data.type === "error") {
+          setState((prev) => ({
+            ...prev,
+            error: data.error,
+            isProcessing: false
+          }));
+        }
+      } catch {
+        setState((prev) => ({ ...prev, error: "Failed to parse agent chat message" }));
+      }
+    };
+    ws.onerror = () => {
+    };
+    ws.onclose = (event) => {
+      setState((prev) => ({ ...prev, isConnected: false }));
+      if (!event.wasClean && retryCountRef.current >= WS_MAX_RETRIES_BEFORE_ERROR) {
+        setState((prev) => ({ ...prev, error: "Unable to connect to agent chat. Retrying..." }));
+      }
+      const terminalCodes = [1003, 1008];
+      if (terminalCodes.includes(event.code) || event.code >= 4e3) {
+        setState((prev) => ({
+          ...prev,
+          error: `Connection rejected (code ${event.code})`
+        }));
+        return;
+      }
+      const delay = Math.min(WS_RECONNECT_BASE_DELAY * Math.pow(2, retryCountRef.current), WS_RECONNECT_MAX_DELAY);
+      retryCountRef.current += 1;
+      reconnectTimeoutRef.current = setTimeout(connect, delay);
+    };
+    wsRef.current = ws;
+  }, [apiUrl]);
+  useEffect(() => {
+    retryCountRef.current = 0;
+    if (sessionId && capabilityToken) {
+      connect();
+    }
+    return () => {
+      if (reconnectTimeoutRef.current) {
+        clearTimeout(reconnectTimeoutRef.current);
+      }
+      if (wsRef.current) {
+        wsRef.current.close();
+        wsRef.current = null;
+      }
+    };
+  }, [sessionId, capabilityToken, connect]);
+  const sendMessage = useCallback(
+    (text) => {
+      const trimmed = text.trim();
+      if (!trimmed || state.isProcessing) {
+        return;
+      }
+      if (!wsRef.current || wsRef.current.readyState !== WebSocket.OPEN) {
+        setState((prev) => ({ ...prev, error: "WebSocket not connected" }));
+        return;
+      }
+      const tokenValidation = validateTokenLimit(trimmed, {
+        maxTokens: TOKEN_LIMITS.USER_MESSAGE
+      });
+      if (!tokenValidation.withinLimit) {
+        setState((prev) => ({ ...prev, error: "Input too large" }));
+        return;
+      }
+      const userMessage = {
+        id: `temp-${Date.now()}`,
+        role: "user",
+        messageType: "user_message",
+        text: trimmed,
+        turnNumber: 999999,
+        messageIndex: Date.now(),
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      setMessages((prev) => [...prev, userMessage]);
+      const message = WebSocketSessionTurnSchema.parse({
+        type: "session:turn",
+        input: { message: trimmed }
+      });
+      wsRef.current.send(JSON.stringify(message));
+      setState((prev) => ({ ...prev, isProcessing: true, error: null }));
+    },
+    [state.isProcessing]
+  );
+  const clearError = useCallback(() => {
+    setState((prev) => ({ ...prev, error: null }));
+  }, []);
+  return {
+    messages,
+    state,
+    sendMessage,
+    clearError,
+    lastTokenUsage
+  };
+}
+async function fetchJson(url, init) {
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    throw new Error(`Request failed with status ${response.status}`);
+  }
+  return await response.json();
+}
+function mergeMessages(historyMessages, liveMessages) {
+  const messageMap = /* @__PURE__ */ new Map();
+  for (const message of historyMessages) {
+    messageMap.set(message.id, message);
+  }
+  for (const message of liveMessages) {
+    if (!message.id.startsWith("temp-")) {
+      messageMap.set(message.id, message);
+      continue;
+    }
+    const exists = Array.from(messageMap.values()).some((existing) => {
+      if (existing.role !== message.role) return false;
+      if (existing.text !== message.text) return false;
+      if (message.metadata && existing.metadata) {
+        return JSON.stringify(existing.metadata) === JSON.stringify(message.metadata);
+      }
+      return true;
+    });
+    if (!exists) {
+      messageMap.set(message.id, message);
+    }
+  }
+  return Array.from(messageMap.values()).sort((a, b) => {
+    if (a.turnNumber !== b.turnNumber) return a.turnNumber - b.turnNumber;
+    return (a.messageIndex ?? 0) - (b.messageIndex ?? 0);
+  });
+}
+function PublicAgentChat({
+  apiUrl,
+  slug,
+  visitorId,
+  metadata,
+  title,
+  className,
+  style,
+  onSessionReady
+}) {
+  const [grant, setGrant] = useState(null);
+  const [capabilityToken, setCapabilityToken] = useState(null);
+  const [session, setSession] = useState(null);
+  const [status, setStatus] = useState("loading");
+  const [error, setError] = useState(null);
+  const [accessCode, setAccessCode] = useState("");
+  const [input, setInput] = useState("");
+  const autoStartedRef = useRef(false);
+  const { data: historyMessages = [] } = usePublicAgentChatMessages(apiUrl, session?.sessionId ?? null, capabilityToken);
+  const { messages: liveMessages, state, sendMessage, clearError } = usePublicAgentChatWebSocket(
+    session?.sessionId ?? null,
+    apiUrl,
+    capabilityToken
+  );
+  useEffect(() => {
+    let cancelled = false;
+    autoStartedRef.current = false;
+    setGrant(null);
+    setCapabilityToken(null);
+    setSession(null);
+    setError(null);
+    setStatus("loading");
+    fetchJson(`${apiUrl}/api/public/agent-chat/${encodeURIComponent(slug)}`).then((payload) => {
+      if (cancelled) return;
+      setGrant(payload.grant);
+      setStatus(payload.grant.requiresCode ? "code-required" : "authorizing");
+    }).catch((requestError) => {
+      if (cancelled) return;
+      setError(requestError instanceof Error ? requestError.message : "Unable to load agent chat");
+      setStatus("error");
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [apiUrl, slug]);
+  const startSession = useCallback(
+    async (code) => {
+      if (!grant) return;
+      try {
+        setError(null);
+        setStatus("authorizing");
+        const authorization = await fetchJson(
+          `${apiUrl}/api/public/agent-chat/${encodeURIComponent(slug)}/authorize`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              ...code ? { code } : {},
+              ...visitorId ? { visitorId } : {}
+            })
+          }
+        );
+        setCapabilityToken(authorization.capabilityToken);
+        const createdSession = await fetchJson(
+          `${apiUrl}/api/public/agent-chat/${encodeURIComponent(slug)}/sessions`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              capabilityToken: authorization.capabilityToken,
+              ...metadata ? { metadata } : {}
+            })
+          }
+        );
+        setSession(createdSession);
+        setStatus("ready");
+        onSessionReady?.(createdSession);
+      } catch (requestError) {
+        setError(requestError instanceof Error ? requestError.message : "Unable to start agent chat");
+        setStatus(grant.requiresCode ? "code-required" : "error");
+      }
+    },
+    [apiUrl, grant, metadata, onSessionReady, slug, visitorId]
+  );
+  useEffect(() => {
+    if (!grant || grant.requiresCode || autoStartedRef.current) {
+      return;
+    }
+    autoStartedRef.current = true;
+    void startSession();
+  }, [grant, startSession]);
+  const allMessages = useMemo(() => mergeMessages(historyMessages, liveMessages), [historyMessages, liveMessages]);
+  const handleSend = () => {
+    const trimmed = input.trim();
+    if (!trimmed || state.isProcessing) return;
+    sendMessage(trimmed);
+    setInput("");
+  };
+  if (status === "loading" || status === "authorizing") {
+    return /* @__PURE__ */ jsx(Center, { className, style: { minHeight: 360, ...style }, children: /* @__PURE__ */ jsx(Loader, { size: "md" }) });
+  }
+  if (status === "code-required") {
+    return /* @__PURE__ */ jsx(Center, { className, style: { minHeight: 360, padding: 16, ...style }, children: /* @__PURE__ */ jsx(Paper, { withBorder: true, p: "lg", radius: "md", style: { width: "min(100%, 420px)" }, children: /* @__PURE__ */ jsx(
+      "form",
+      {
+        onSubmit: (event) => {
+          event.preventDefault();
+          void startSession(accessCode);
+        },
+        children: /* @__PURE__ */ jsxs(Stack, { children: [
+          /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
+            /* @__PURE__ */ jsx(IconLock, { size: 18 }),
+            /* @__PURE__ */ jsx(Title, { order: 2, size: "h4", children: title ?? "Agent Chat" })
+          ] }),
+          error && /* @__PURE__ */ jsx(Alert, { color: "red", icon: /* @__PURE__ */ jsx(IconAlertCircle, { size: 16 }), children: error }),
+          /* @__PURE__ */ jsx(
+            PasswordInput,
+            {
+              label: "Access code",
+              value: accessCode,
+              onChange: (event) => setAccessCode(event.currentTarget.value),
+              autoComplete: "one-time-code",
+              required: true
+            }
+          ),
+          /* @__PURE__ */ jsx(Button, { type: "submit", leftSection: /* @__PURE__ */ jsx(IconSend, { size: 16 }), disabled: !accessCode.trim(), children: "Continue" })
+        ] })
+      }
+    ) }) });
+  }
+  if (status === "error") {
+    return /* @__PURE__ */ jsx(Center, { className, style: { minHeight: 360, padding: 16, ...style }, children: /* @__PURE__ */ jsx(Alert, { color: "red", icon: /* @__PURE__ */ jsx(IconAlertCircle, { size: 16 }), title: title ?? "Agent Chat", children: /* @__PURE__ */ jsx(Text, { size: "sm", children: error ?? "Unable to load agent chat" }) }) });
+  }
+  return /* @__PURE__ */ jsx("div", { className, style: { height: "100%", minHeight: 480, display: "flex", flexDirection: "column", ...style }, children: /* @__PURE__ */ jsx(
+    ChatInterface,
+    {
+      messages: allMessages,
+      input,
+      onInputChange: setInput,
+      onSendMessage: handleSend,
+      isProcessing: state.isProcessing,
+      isConnected: state.isConnected,
+      error: state.error,
+      onClearError: clearError,
+      emptyStateText: "No messages yet",
+      emptyStateSubtext: "Send a message to start the conversation",
+      placeholder: "Message the agent...",
+      messageAreaVariant: "plain"
+    }
+  ) });
+}
+
+export { PublicAgentChat, publicAgentChatKeys, usePublicAgentChatMessages, usePublicAgentChatWebSocket };