@paymanai/payman-typescript-ask-sdk 4.0.27 → 4.0.29

package/dist/index.js

@@ -1814,6 +1814,284 @@ function useVoice(config = {}, callbacks = {}) {
     reset
   };
 }
+var DEFAULT_PAGE_SIZE = 20;
+var DEFAULT_MESSAGES_PAGE_SIZE = 100;
+function defaultParseSessions(json) {
+  const body = json;
+  const rows = Array.isArray(body?.data) ? body.data : [];
+  const data = rows.map((row) => ({ ...row, title: row.title ?? row.sessionTitle ?? null }));
+  return { data, total: body?.total };
+}
+function defaultParseMessages(json) {
+  const body = json;
+  return { data: Array.isArray(body?.data) ? body.data : [] };
+}
+function withQuery(path, params) {
+  const qs = Object.entries(params).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+  if (!qs) return path;
+  return `${path}${path.includes("?") ? "&" : "?"}${qs}`;
+}
+function toFeedbackState(feedback) {
+  const value = feedback?.feedback;
+  if (!value) return null;
+  return value === "POSITIVE" ? "up" : "down";
+}
+function toMessageDisplay(rows, sessionId) {
+  return rows.flatMap((row) => {
+    const timestamp = row.startTime || row.endTime || (/* @__PURE__ */ new Date()).toISOString();
+    const out = [
+      {
+        id: `${row.id}:user`,
+        sessionId,
+        role: "user",
+        content: row.sessionUserIntent,
+        timestamp
+      }
+    ];
+    if (row.agentResponse) {
+      out.push({
+        id: `${row.id}:assistant`,
+        sessionId,
+        role: "assistant",
+        content: row.agentResponse,
+        timestamp: row.endTime || timestamp,
+        executionId: row.id,
+        isError: row.status === "FAILED",
+        feedback: toFeedbackState(row.feedback)
+      });
+    }
+    return out;
+  });
+}
+function useChatSessions({
+  api,
+  sessions,
+  initialSessionId
+}) {
+  const enabled = sessions?.enabled === true;
+  const listEndpoint = sessions?.listEndpoint ?? "/api/conversations/sessions";
+  const messagesEndpointTemplate = sessions?.messagesEndpoint ?? "/api/conversations/sessions/{sessionId}/messages";
+  const pageSize = sessions?.pageSize ?? DEFAULT_PAGE_SIZE;
+  const messagesPageSize = sessions?.messagesPageSize ?? DEFAULT_MESSAGES_PAGE_SIZE;
+  const parseSessionsResponse = sessions?.parseSessionsResponse ?? defaultParseSessions;
+  const parseMessagesResponse = sessions?.parseMessagesResponse ?? defaultParseMessages;
+  const [sessionsList, setSessionsList] = react.useState([]);
+  const [isLoadingList, setIsLoadingList] = react.useState(enabled);
+  const [isLoadingMore, setIsLoadingMore] = react.useState(false);
+  const [listError, setListError] = react.useState(null);
+  const hasLoadedOnceRef = react.useRef(false);
+  const [page, setPage] = react.useState(0);
+  const [total, setTotal] = react.useState(null);
+  const [lastPageFull, setLastPageFull] = react.useState(false);
+  const [selectedSessionId, setSelectedSessionId] = react.useState(
+    initialSessionId ?? null
+  );
+  const [draftSessionId, setDraftSessionId] = react.useState(generateId);
+  const [selectedMessages, setSelectedMessages] = react.useState([]);
+  const [isLoadingMessages, setIsLoadingMessages] = react.useState(
+    enabled && initialSessionId != null
+  );
+  const [messagesError, setMessagesError] = react.useState(null);
+  const [refetchTick, setRefetchTick] = react.useState(0);
+  const baseUrl = (api.baseUrl || "").replace(/\/+$/, "");
+  const apiHeaders = api.headers;
+  const authToken = api.authToken;
+  const headersKey = JSON.stringify(apiHeaders ?? {});
+  const requestHeaders = react.useMemo(() => {
+    const headers = { Accept: "application/json", ...apiHeaders ?? {} };
+    if (authToken && !headers.Authorization) headers.Authorization = `Bearer ${authToken}`;
+    return headers;
+  }, [headersKey, authToken]);
+  const hasMore = total != null ? sessionsList.length < total : lastPageFull;
+  react.useEffect(() => {
+    setPage(0);
+    hasLoadedOnceRef.current = false;
+  }, [enabled, baseUrl, listEndpoint, pageSize, requestHeaders]);
+  react.useEffect(() => {
+    setPage(0);
+  }, [refetchTick]);
+  react.useEffect(() => {
+    if (!enabled) return;
+    const ctrl = new AbortController();
+    const isFirstPage = page === 0;
+    if (isFirstPage && !hasLoadedOnceRef.current) setIsLoadingList(true);
+    else if (!isFirstPage) setIsLoadingMore(true);
+    setListError(null);
+    fetch(withQuery(`${baseUrl}${listEndpoint}`, { page, limit: pageSize }), {
+      method: "GET",
+      headers: requestHeaders,
+      signal: ctrl.signal
+    }).then(async (res) => {
+      if (!res.ok) throw new Error(`Failed to load chats (${res.status})`);
+      return res.json();
+    }).then((json) => {
+      const parsed = parseSessionsResponse(json);
+      setSessionsList((prev) => isFirstPage ? parsed.data : [...prev, ...parsed.data]);
+      setTotal(parsed.total ?? null);
+      setLastPageFull(parsed.data.length >= pageSize);
+      hasLoadedOnceRef.current = true;
+    }).catch((e) => {
+      if (e.name === "AbortError") return;
+      setListError(e instanceof Error ? e.message : "Failed to load chats");
+    }).finally(() => {
+      setIsLoadingList(false);
+      setIsLoadingMore(false);
+    });
+    return () => ctrl.abort();
+  }, [enabled, baseUrl, listEndpoint, pageSize, requestHeaders, refetchTick, page]);
+  react.useEffect(() => {
+    if (!enabled || !selectedSessionId) {
+      setSelectedMessages([]);
+      return;
+    }
+    const ctrl = new AbortController();
+    setIsLoadingMessages(true);
+    setMessagesError(null);
+    const path = messagesEndpointTemplate.replace(
+      "{sessionId}",
+      encodeURIComponent(selectedSessionId)
+    );
+    fetch(withQuery(`${baseUrl}${path}`, { limit: messagesPageSize }), {
+      method: "GET",
+      headers: requestHeaders,
+      signal: ctrl.signal
+    }).then(async (res) => {
+      if (!res.ok) throw new Error(`Failed to load messages (${res.status})`);
+      return res.json();
+    }).then(
+      (json) => setSelectedMessages(
+        toMessageDisplay(parseMessagesResponse(json).data, selectedSessionId)
+      )
+    ).catch((e) => {
+      if (e.name === "AbortError") return;
+      setMessagesError(e instanceof Error ? e.message : "Failed to load messages");
+      setSelectedMessages([]);
+    }).finally(() => setIsLoadingMessages(false));
+    return () => ctrl.abort();
+  }, [enabled, selectedSessionId, baseUrl, messagesEndpointTemplate, messagesPageSize, requestHeaders]);
+  const loadMore = react.useCallback(() => {
+    setPage((prev) => {
+      if (isLoadingList || isLoadingMore || !hasMore) return prev;
+      return prev + 1;
+    });
+  }, [isLoadingList, isLoadingMore, hasMore]);
+  const selectSession = react.useCallback((sessionId) => {
+    setSelectedSessionId(sessionId);
+    setSelectedMessages([]);
+  }, []);
+  const startNewSession = react.useCallback(() => {
+    setSelectedSessionId(null);
+    setDraftSessionId(generateId());
+    setSelectedMessages([]);
+  }, []);
+  const refetch = react.useCallback(() => setRefetchTick((tick) => tick + 1), []);
+  const noteSentMessage = react.useCallback(
+    (text) => {
+      const id = selectedSessionId ?? draftSessionId;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const trimmed = text.trim();
+      setSessionsList((prev) => {
+        const idx = prev.findIndex((s) => s.sessionId === id);
+        if (idx >= 0) {
+          const existing = prev[idx];
+          const bumped = {
+            ...existing,
+            lastMessageAt: now,
+            messageCount: (existing.messageCount ?? 0) + 1,
+            title: existing.title?.trim() ? existing.title : trimmed
+          };
+          return [bumped, ...prev.slice(0, idx), ...prev.slice(idx + 1)];
+        }
+        const fresh = {
+          sessionId: id,
+          title: trimmed,
+          messageCount: 1,
+          lastMessageAt: now,
+          status: "PROCESSING"
+        };
+        return [fresh, ...prev];
+      });
+    },
+    [selectedSessionId, draftSessionId]
+  );
+  return {
+    enabled,
+    sessionsList,
+    isLoadingList,
+    listError,
+    total,
+    hasMore,
+    isLoadingMore,
+    loadMore,
+    noteSentMessage,
+    selectedSessionId,
+    activeSessionId: selectedSessionId ?? draftSessionId,
+    selectSession,
+    startNewSession,
+    selectedMessages,
+    isLoadingMessages,
+    messagesError,
+    refetch
+  };
+}
+function deriveStatus(enabled, blocked) {
+  if (blocked === true) return "blocked";
+  if (enabled === false) return "disabled";
+  if (enabled === true) return "available";
+  return "unknown";
+}
+function defaultParse(json) {
+  const body = json;
+  return {
+    available: body?.enabled === true && body?.blocked !== true,
+    status: deriveStatus(body?.enabled, body?.blocked),
+    config: body ?? void 0
+  };
+}
+function useAgentConfig({ api, availability }) {
+  const enabled = availability?.enabled === true;
+  const endpoint = availability?.endpoint ?? "/api/agent/config";
+  const parseResponse = availability?.parseResponse ?? defaultParse;
+  const [available, setAvailable] = react.useState(null);
+  const [status, setStatus] = react.useState("unknown");
+  const [config, setConfig] = react.useState(void 0);
+  const [isLoading, setIsLoading] = react.useState(enabled);
+  const [error, setError] = react.useState(null);
+  const [refetchTick, setRefetchTick] = react.useState(0);
+  const baseUrl = (api.baseUrl || "").replace(/\/+$/, "");
+  const apiHeaders = api.headers;
+  const authToken = api.authToken;
+  const requestHeaders = react.useMemo(() => {
+    const headers = { Accept: "application/json", ...apiHeaders ?? {} };
+    if (authToken && !headers.Authorization) headers.Authorization = `Bearer ${authToken}`;
+    return headers;
+  }, [apiHeaders, authToken]);
+  react.useEffect(() => {
+    if (!enabled) return;
+    const ctrl = new AbortController();
+    setIsLoading(true);
+    setError(null);
+    fetch(`${baseUrl}${endpoint}`, {
+      method: "GET",
+      headers: requestHeaders,
+      signal: ctrl.signal
+    }).then(async (res) => {
+      if (!res.ok) throw new Error(`Failed to check availability (${res.status})`);
+      return res.json();
+    }).then((json) => {
+      const parsed = parseResponse(json);
+      setAvailable(parsed.available);
+      setStatus(parsed.status ?? deriveStatus(parsed.available, void 0));
+      setConfig(parsed.config);
+    }).catch((e) => {
+      if (e.name === "AbortError") return;
+      setError(e instanceof Error ? e.message : "Failed to check availability");
+    }).finally(() => setIsLoading(false));
+    return () => ctrl.abort();
+  }, [enabled, baseUrl, endpoint, requestHeaders, refetchTick]);
+  const refetch = react.useCallback(() => setRefetchTick((tick) => tick + 1), []);
+  return { enabled, available, status, config, isLoading, error, refetch };
+}
 
 // src/utils/jsonSchemaForm.ts
 function classifyField(field) {
@@ -1960,6 +2238,8 @@ exports.resendUserAction = resendUserAction;
 exports.resolveUserActionExpiresAt = resolveUserActionExpiresAt;
 exports.streamWorkflowEvents = streamWorkflowEvents;
 exports.submitUserAction = submitUserAction;
+exports.useAgentConfig = useAgentConfig;
+exports.useChatSessions = useChatSessions;
 exports.useChatV2 = useChatV2;
 exports.useVoice = useVoice;
 exports.validateField = validateField;