@paymanai/payman-typescript-ask-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,600 @@
+'use strict';
+
+var react = require('react');
+
+// src/hooks/useChat.ts
+
+// src/utils/generateId.ts
+function generateId() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// src/utils/streamingClient.ts
+function parseJSONBuffer(buffer) {
+  const events = [];
+  let braceCount = 0;
+  let startIndex = 0;
+  let inString = false;
+  let escapeNext = false;
+  let lastParsedIndex = -1;
+  for (let i = 0; i < buffer.length; i++) {
+    const char = buffer[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (char === '"' && !escapeNext) {
+      inString = !inString;
+      continue;
+    }
+    if (inString) {
+      continue;
+    }
+    if (char === "{") {
+      if (braceCount === 0) {
+        startIndex = i;
+      }
+      braceCount++;
+    } else if (char === "}") {
+      braceCount--;
+      if (braceCount === 0) {
+        const jsonStr = buffer.substring(startIndex, i + 1);
+        try {
+          const parsed = JSON.parse(jsonStr);
+          const event = parsed;
+          events.push(event);
+          lastParsedIndex = i;
+        } catch (err) {
+          console.error("Failed to parse JSON event:", jsonStr, err);
+        }
+      }
+    }
+  }
+  const remaining = lastParsedIndex >= 0 ? buffer.substring(lastParsedIndex + 1) : buffer;
+  return { events, remaining };
+}
+async function streamWorkflowEvents(url, body, headers, options = {}) {
+  const { signal, onEvent, onError, onComplete } = options;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        if (buffer.trim()) {
+          const { events: events2 } = parseJSONBuffer(buffer);
+          for (const event of events2) {
+            onEvent?.(event);
+          }
+        }
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const { events, remaining } = parseJSONBuffer(buffer);
+      for (const event of events) {
+        onEvent?.(event);
+      }
+      buffer = remaining;
+    }
+    onComplete?.();
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return;
+    }
+    onError?.(error);
+  }
+}
+
+// src/utils/eventProcessor.ts
+function getEventMessage(event) {
+  if (event.message?.trim()) {
+    return event.message;
+  }
+  if (event.errorMessage?.trim()) {
+    return event.errorMessage;
+  }
+  const eventType = event.eventType;
+  switch (eventType) {
+    case "STARTED":
+    case "WORKFLOW_STARTED":
+      return "Starting workflow...";
+    case "ORCHESTRATOR_THINKING":
+      return "Planning execution strategy...";
+    case "ORCHESTRATOR_COMPLETED":
+      return "Planning complete";
+    case "INTENT_STARTED":
+      return event.workerName ? `${event.workerName} started` : "Processing intent...";
+    case "INTENT_PROGRESS":
+      return event.workerName ? `${event.workerName} in progress` : "Thinking...";
+    case "INTENT_COMPLETED":
+      return event.workerName ? `${event.workerName} completed` : "Intent completed";
+    case "AGGREGATOR_THINKING":
+      return "Combining results...";
+    case "AGGREGATOR_COMPLETED":
+      return "Results combined";
+    case "COMPLETED":
+    case "WORKFLOW_COMPLETED":
+      return "Workflow completed successfully";
+    case "ERROR":
+    case "WORKFLOW_ERROR":
+    case "INTENT_ERROR":
+      return event.errorMessage || "An error occurred";
+    default:
+      return eventType;
+  }
+}
+function extractResponseContent(response) {
+  if (typeof response === "string") {
+    return response;
+  }
+  if (typeof response === "object" && response !== null) {
+    const resp = response;
+    if ("text" in resp && typeof resp.text === "string") {
+      return resp.text;
+    }
+    if ("content" in resp && typeof resp.content === "string") {
+      return resp.content;
+    }
+    if ("message" in resp && typeof resp.message === "string") {
+      return resp.message;
+    }
+    if ("answer" in resp && typeof resp.answer === "string") {
+      return resp.answer;
+    }
+    return JSON.stringify(response);
+  }
+  return "";
+}
+function processStreamEvent(event, state) {
+  const eventType = event.eventType;
+  const message = getEventMessage(event);
+  if ((eventType === "COMPLETED" || eventType === "WORKFLOW_COMPLETED") && event.response !== void 0) {
+    const content = extractResponseContent(event.response);
+    if (content) {
+      state.accumulatedContent = content;
+      state.finalData = event.response;
+    }
+  }
+  if (eventType === "STARTED" || eventType === "WORKFLOW_STARTED") ; else if (eventType === "COMPLETED" || eventType === "WORKFLOW_COMPLETED") {
+    state.steps.forEach((step) => {
+      if (step.status === "in_progress") {
+        step.status = "completed";
+      }
+    });
+  } else if (eventType === "INTENT_ERROR") {
+    state.hasError = true;
+    state.errorMessage = message || event.errorMessage || "An error occurred";
+    const intentStep = state.steps.find(
+      (s) => s.eventType === "INTENT_STARTED" && s.status === "in_progress"
+    );
+    if (intentStep) {
+      intentStep.status = "error";
+    }
+  } else if (eventType === "ERROR" || eventType === "WORKFLOW_ERROR") {
+    state.hasError = true;
+    state.errorMessage = message || event.errorMessage || "An error occurred";
+  } else if (eventType === "ORCHESTRATOR_COMPLETED") {
+    const orchestratorStep = state.steps.find(
+      (s) => s.eventType === "ORCHESTRATOR_THINKING" && s.status === "in_progress"
+    );
+    if (orchestratorStep) {
+      orchestratorStep.status = "completed";
+      if (event.elapsedMs) {
+        orchestratorStep.elapsedMs = event.elapsedMs;
+      }
+      if (orchestratorStep.id === state.currentExecutingStepId) {
+        state.currentExecutingStepId = void 0;
+      }
+    }
+  } else if (eventType === "INTENT_COMPLETED") {
+    const intentStep = state.steps.find(
+      (s) => s.eventType === "INTENT_STARTED" && s.status === "in_progress"
+    );
+    if (intentStep) {
+      intentStep.status = "completed";
+      if (event.elapsedMs) {
+        intentStep.elapsedMs = event.elapsedMs;
+      }
+      if (intentStep.id === state.currentExecutingStepId) {
+        state.currentExecutingStepId = void 0;
+      }
+    }
+  } else if (eventType === "AGGREGATOR_COMPLETED") {
+    const aggregatorStep = state.steps.find(
+      (s) => s.eventType === "AGGREGATOR_THINKING" && s.status === "in_progress"
+    );
+    if (aggregatorStep) {
+      aggregatorStep.status = "completed";
+      if (event.elapsedMs) {
+        aggregatorStep.elapsedMs = event.elapsedMs;
+      }
+      if (aggregatorStep.id === state.currentExecutingStepId) {
+        state.currentExecutingStepId = void 0;
+      }
+    }
+  } else if (eventType === "ORCHESTRATOR_THINKING" || eventType === "INTENT_STARTED" || eventType === "INTENT_PROGRESS" || eventType === "AGGREGATOR_THINKING") {
+    if (eventType === "INTENT_PROGRESS") {
+      const intentStep = state.steps.find(
+        (s) => s.eventType === "INTENT_STARTED" && s.status === "in_progress"
+      );
+      if (intentStep) {
+        intentStep.message = message;
+        state.currentExecutingStepId = intentStep.id;
+      } else {
+        const stepId = `step-${state.stepCounter++}`;
+        state.steps.push({
+          id: stepId,
+          eventType: "INTENT_STARTED",
+          message,
+          status: "in_progress",
+          timestamp: Date.now(),
+          elapsedMs: event.elapsedMs
+        });
+        state.currentExecutingStepId = stepId;
+      }
+    } else {
+      const stepId = `step-${state.stepCounter++}`;
+      state.steps.push({
+        id: stepId,
+        eventType,
+        message,
+        status: "in_progress",
+        timestamp: Date.now(),
+        elapsedMs: event.elapsedMs
+      });
+      state.currentExecutingStepId = stepId;
+    }
+  }
+  return state;
+}
+
+// src/utils/messageStateManager.ts
+function createStreamingMessageUpdate(state) {
+  const hasCompletedContent = state.accumulatedContent && state.finalData !== void 0;
+  return {
+    streamingContent: state.hasError ? `Oops, something went wrong. Please try again.
+
+${state.errorMessage}` : hasCompletedContent ? state.accumulatedContent : "",
+    content: state.hasError ? `Oops, something went wrong. Please try again.
+
+${state.errorMessage}` : "",
+    currentMessage: state.hasError ? void 0 : state.currentMessage,
+    streamProgress: state.hasError ? "error" : "processing",
+    isError: state.hasError,
+    errorDetails: state.hasError ? state.errorMessage : void 0,
+    executionId: state.executionId,
+    sessionId: state.sessionId,
+    steps: state.hasError ? [] : [...state.steps],
+    // Don't show steps on error
+    currentExecutingStepId: state.hasError ? void 0 : state.currentExecutingStepId,
+    isCancelled: false
+  };
+}
+function createErrorMessageUpdate(error, state) {
+  const isAborted = error.name === "AbortError";
+  return {
+    isStreaming: false,
+    streamProgress: isAborted ? "processing" : "error",
+    isError: !isAborted,
+    isCancelled: isAborted,
+    errorDetails: isAborted ? void 0 : error.message,
+    content: isAborted ? state.accumulatedContent || "" : state.accumulatedContent || `Oops, something went wrong. Please try again.
+
+${error.message}`,
+    // Preserve currentMessage when cancelled so UI can show it
+    currentMessage: isAborted ? state.currentMessage || "Thinking..." : void 0,
+    steps: [...state.steps].map((step) => {
+      if (step.status === "in_progress" && isAborted) {
+        return { ...step, status: "pending" };
+      }
+      return step;
+    }),
+    currentExecutingStepId: void 0
+  };
+}
+function createFinalMessage(streamingId, state) {
+  return {
+    id: streamingId,
+    sessionId: state.sessionId,
+    role: "assistant",
+    content: state.hasError ? `Oops, something went wrong. Please try again.
+
+${state.errorMessage}` : state.accumulatedContent || "",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    isStreaming: false,
+    streamProgress: state.hasError ? "error" : "completed",
+    isError: state.hasError,
+    errorDetails: state.hasError ? state.errorMessage : void 0,
+    executionId: state.executionId,
+    tracingData: state.finalData,
+    steps: state.hasError ? [] : [...state.steps],
+    // Don't show steps on error
+    isCancelled: false,
+    currentExecutingStepId: void 0
+  };
+}
+function createCancelledMessageUpdate(steps, currentMessage) {
+  const updatedSteps = steps.map((step) => {
+    if (step.status === "in_progress") {
+      return { ...step, status: "pending" };
+    }
+    return step;
+  });
+  return {
+    isStreaming: false,
+    isCancelled: true,
+    steps: updatedSteps,
+    currentExecutingStepId: void 0,
+    // Preserve currentMessage so UI can show it with X icon
+    currentMessage: currentMessage || "Thinking..."
+  };
+}
+
+// src/utils/requestBuilder.ts
+function buildRequestBody(config, userMessage, sessionId) {
+  const sessionOwner = config.sessionParams;
+  const sessionAttributes = sessionOwner?.attributes && Object.keys(sessionOwner.attributes).length > 0 ? sessionOwner.attributes : void 0;
+  return {
+    workflowName: config.workflowName,
+    userInput: userMessage,
+    sessionId,
+    sessionOwnerId: sessionOwner?.id || "",
+    sessionOwnerLabel: sessionOwner?.name || "",
+    sessionAttributes,
+    options: {
+      clientTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+    }
+  };
+}
+function buildStreamingUrl(config) {
+  const endpoint = config.api.streamEndpoint || "/api/workflows/ask/stream";
+  const stage = config.stage || "DEV";
+  const version = config.workflowVersion || 1;
+  return `${config.api.baseUrl}${endpoint}?stage=${stage}&workflowVersion=${version}`;
+}
+function buildRequestHeaders(config) {
+  const headers = {
+    ...config.api.headers
+  };
+  if (config.api.authToken) {
+    headers.Authorization = `Bearer ${config.api.authToken}`;
+  }
+  return headers;
+}
+function useStreamManager(config, callbacks, setMessages, setIsWaitingForResponse) {
+  const abortControllerRef = react.useRef(null);
+  const startStream = react.useCallback(
+    async (userMessage, streamingId, sessionId) => {
+      abortControllerRef.current?.abort();
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
+      const state = {
+        accumulatedContent: "",
+        executionId: void 0,
+        currentSessionId: void 0,
+        finalData: void 0,
+        steps: [],
+        stepCounter: 0,
+        currentExecutingStepId: void 0,
+        hasError: false,
+        errorMessage: ""
+      };
+      const requestBody = buildRequestBody(config, userMessage, sessionId);
+      const url = buildStreamingUrl(config);
+      const headers = buildRequestHeaders(config);
+      try {
+        await streamWorkflowEvents(url, requestBody, headers, {
+          signal: abortController.signal,
+          onEvent: (event) => {
+            if (abortController.signal.aborted) {
+              return;
+            }
+            if (event.executionId) state.executionId = event.executionId;
+            if (event.sessionId) state.currentSessionId = event.sessionId;
+            processStreamEvent(event, state);
+            const currentMessage = event.message?.trim() || event.errorMessage?.trim();
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? {
+                  ...msg,
+                  ...createStreamingMessageUpdate({
+                    ...state,
+                    currentMessage
+                  })
+                } : msg
+              )
+            );
+          },
+          onError: (error) => {
+            setIsWaitingForResponse(false);
+            if (error.name !== "AbortError") {
+              callbacks.onError?.(error);
+            }
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? {
+                  ...msg,
+                  ...createErrorMessageUpdate(error, state)
+                } : msg
+              )
+            );
+          },
+          onComplete: () => {
+            setIsWaitingForResponse(false);
+            if (state.currentSessionId && state.currentSessionId !== sessionId) {
+              callbacks.onSessionIdChange?.(state.currentSessionId);
+            }
+            const finalMessage = createFinalMessage(streamingId, {
+              ...state,
+              sessionId: state.currentSessionId || sessionId
+            });
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? finalMessage : msg
+              )
+            );
+            callbacks.onStreamComplete?.(finalMessage);
+          }
+        });
+        return state.currentSessionId;
+      } catch (error) {
+        setIsWaitingForResponse(false);
+        if (error.name !== "AbortError") {
+          callbacks.onError?.(error);
+        }
+        setMessages(
+          (prev) => prev.map(
+            (msg) => msg.id === streamingId ? {
+              ...msg,
+              ...createErrorMessageUpdate(error, state)
+            } : msg
+          )
+        );
+        return state.currentSessionId;
+      }
+    },
+    [config, callbacks, setMessages, setIsWaitingForResponse]
+  );
+  const cancelStream = react.useCallback(() => {
+    abortControllerRef.current?.abort();
+  }, []);
+  return {
+    startStream,
+    cancelStream,
+    abortControllerRef
+  };
+}
+
+// src/hooks/useChat.ts
+function useChat(config, callbacks = {}) {
+  const [messages, setMessages] = react.useState([]);
+  const [isWaitingForResponse, setIsWaitingForResponse] = react.useState(false);
+  const sessionIdRef = react.useRef(void 0);
+  const { startStream, cancelStream: cancelStreamManager, abortControllerRef } = useStreamManager(
+    config,
+    callbacks,
+    setMessages,
+    setIsWaitingForResponse
+  );
+  const sendMessage = react.useCallback(
+    async (userMessage) => {
+      if (!userMessage.trim()) return;
+      if (!sessionIdRef.current && config.autoGenerateSessionId !== false) {
+        sessionIdRef.current = generateId();
+        callbacks.onSessionIdChange?.(sessionIdRef.current);
+      }
+      const userMessageId = `user-${Date.now()}`;
+      const userMsg = {
+        id: userMessageId,
+        sessionId: sessionIdRef.current,
+        role: "user",
+        content: userMessage,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setMessages((prev) => [...prev, userMsg]);
+      callbacks.onMessageSent?.(userMessage);
+      setIsWaitingForResponse(true);
+      callbacks.onStreamStart?.();
+      const streamingId = `assistant-${Date.now()}`;
+      const streamingMsg = {
+        id: streamingId,
+        sessionId: sessionIdRef.current,
+        role: "assistant",
+        content: "",
+        streamingContent: "",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        isStreaming: true,
+        streamProgress: "started",
+        steps: [],
+        currentExecutingStepId: void 0,
+        isCancelled: false,
+        currentMessage: void 0
+      };
+      setMessages((prev) => [...prev, streamingMsg]);
+      const newSessionId = await startStream(
+        userMessage,
+        streamingId,
+        sessionIdRef.current
+      );
+      if (newSessionId && newSessionId !== sessionIdRef.current) {
+        sessionIdRef.current = newSessionId;
+      }
+    },
+    [config, callbacks, startStream, setMessages, setIsWaitingForResponse]
+  );
+  const clearMessages = react.useCallback(() => {
+    setMessages([]);
+  }, []);
+  const cancelStream = react.useCallback(() => {
+    cancelStreamManager();
+    setIsWaitingForResponse(false);
+    setMessages(
+      (prev) => prev.map((msg) => {
+        if (msg.isStreaming) {
+          return {
+            ...msg,
+            ...createCancelledMessageUpdate(
+              msg.steps || [],
+              msg.currentMessage
+            )
+          };
+        }
+        return msg;
+      })
+    );
+  }, [cancelStreamManager]);
+  const resetSession = react.useCallback(() => {
+    setMessages([]);
+    sessionIdRef.current = void 0;
+    abortControllerRef.current?.abort();
+    setIsWaitingForResponse(false);
+  }, []);
+  const getSessionId = react.useCallback(() => {
+    return sessionIdRef.current;
+  }, []);
+  const getMessages = react.useCallback(() => {
+    return messages;
+  }, [messages]);
+  return {
+    messages,
+    sendMessage,
+    clearMessages,
+    cancelStream,
+    resetSession,
+    getSessionId,
+    getMessages,
+    isWaitingForResponse,
+    sessionId: sessionIdRef.current
+  };
+}
+
+exports.generateId = generateId;
+exports.streamWorkflowEvents = streamWorkflowEvents;
+exports.useChat = useChat;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map