@baseai/core/react/dist/index.js

The Web AI Framework's core - BaseAI.dev

'use client'
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/react/index.ts
var react_exports = {};
__export(react_exports, {
  usePipe: () => usePipe
});
module.exports = __toCommonJS(react_exports);

// src/react/use-pipe.ts
var import_react = require("react");
var import_zod = require("zod");

// src/helpers/stream.ts
var import_ChatCompletionStream = require("openai/lib/ChatCompletionStream");
var import_streaming = require("openai/streaming");
var fromReadableStream = (readableStream) => {
  return import_ChatCompletionStream.ChatCompletionStream.fromReadableStream(readableStream);
};
var getRunner = (readableStream) => {
  return fromReadableStream(readableStream);
};

// src/utils/is-prod.ts
var FORCE_PROD = false;
var TEST_PROD_LOCALLY = FORCE_PROD;
function isProd() {
  if (TEST_PROD_LOCALLY) return true;
  return process.env.NODE_ENV === "production";
}

// src/react/use-pipe.ts
var uuidSchema = import_zod.z.string().uuid();
var externalThreadIdSchema = uuidSchema.optional();
function usePipe({
  apiRoute = "/langbase/pipes/run-stream",
  onResponse,
  onFinish,
  onConnect,
  onError,
  threadId: initialThreadId,
  initialMessages = [],
  stream = true
} = {}) {
  const [messages, setMessages] = (0, import_react.useState)(initialMessages);
  const [input, setInput] = (0, import_react.useState)("");
  const [isLoading, setIsLoading] = (0, import_react.useState)(false);
  const [error, setError] = (0, import_react.useState)(null);
  const abortControllerRef = (0, import_react.useRef)(null);
  const threadIdRef = (0, import_react.useRef)(
    initialThreadId || void 0
  );
  const messagesRef = (0, import_react.useRef)(initialMessages);
  const isFirstRequestRef = (0, import_react.useRef)(true);
  const updateMessages = (0, import_react.useCallback)((newMessages) => {
    messagesRef.current = newMessages;
    setMessages(newMessages);
  }, []);
  const processStreamResponse = (0, import_react.useCallback)(
    async (runner) => {
      var _a, _b, _c;
      let assistantMessage = { role: "assistant", content: "" };
      updateMessages([...messagesRef.current, assistantMessage]);
      for await (const chunk of runner) {
        if ((_a = abortControllerRef.current) == null ? void 0 : _a.signal.aborted) break;
        const content = ((_c = (_b = chunk.choices[0]) == null ? void 0 : _b.delta) == null ? void 0 : _c.content) || "";
        assistantMessage.content += content;
        updateMessages([
          ...messagesRef.current.slice(0, -1),
          { ...assistantMessage }
        ]);
        onResponse == null ? void 0 : onResponse({ ...assistantMessage });
      }
      onFinish == null ? void 0 : onFinish(messagesRef.current);
    },
    [updateMessages, onResponse, onFinish]
  );
  const processNonStreamResponse = (0, import_react.useCallback)(
    (result) => {
      const assistantMessage = {
        role: "assistant",
        content: result.completion
      };
      const newMessages = [...messagesRef.current, assistantMessage];
      updateMessages(newMessages);
      onResponse == null ? void 0 : onResponse(assistantMessage);
      onFinish == null ? void 0 : onFinish(newMessages);
    },
    [updateMessages, onResponse, onFinish]
  );
  const setThreadId = (0, import_react.useCallback)((newThreadId) => {
    const isValidThreadId = externalThreadIdSchema.safeParse(newThreadId).success;
    if (isValidThreadId) {
      threadIdRef.current = newThreadId;
    } else {
      throw new Error("Invalid thread ID");
    }
  }, []);
  const getMessagesToSend = (0, import_react.useCallback)(
    (updatedMessages) => {
      const isInitialRequest = isFirstRequestRef.current;
      isFirstRequestRef.current = false;
      if (!isProd()) {
        return [updatedMessages, false];
      }
      if (isInitialRequest) {
        return [updatedMessages, false];
      } else {
        const lastMessageOnly = updatedMessages.length > initialMessages.length;
        return [
          lastMessageOnly ? [updatedMessages[updatedMessages.length - 1]] : updatedMessages,
          lastMessageOnly
        ];
      }
    },
    [initialMessages]
  );
  const sendRequest = (0, import_react.useCallback)(
    async (content, options = {}) => {
      abortControllerRef.current = new AbortController();
      const { signal } = abortControllerRef.current;
      try {
        setIsLoading(true);
        setError(null);
        onConnect == null ? void 0 : onConnect();
        let updatedMessages = messagesRef.current;
        const hasContent = content && content.trim();
        if (hasContent) {
          updatedMessages = [
            ...messagesRef.current,
            { role: "user", content }
          ];
        }
        updateMessages(updatedMessages);
        const [messagesToSend, lastMessageOnly] = getMessagesToSend(updatedMessages);
        if (messagesToSend.length === 0 && !options.allowEmptySubmit) {
          throw new Error(
            "At least one message or initial message is required"
          );
        }
        const requestBody = {
          messages: messagesToSend,
          stream,
          lastMessageOnly,
          ...options.body
        };
        if (threadIdRef.current && uuidSchema.safeParse(threadIdRef.current).success) {
          requestBody.threadId = threadIdRef.current;
        }
        const response = await fetch(apiRoute, {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
            ...options.headers || {}
          },
          body: JSON.stringify(requestBody),
          signal
        });
        if (!response.ok) await processErrorResponse(response);
        const newThreadId = response.headers.get("lb-thread-id");
        if (newThreadId) threadIdRef.current = newThreadId;
        if (stream && response.body) {
          await processStreamResponse(getRunner(response.body));
        } else {
          const result = await response.json();
          processNonStreamResponse(result);
        }
      } catch (err) {
        if (err instanceof Error && err.name !== "AbortError") {
          setError(err);
          onError == null ? void 0 : onError(err);
        } else if (err.name !== "AbortError") {
          throw new Error("Failed to send message");
        }
      } finally {
        setIsLoading(false);
      }
    },
    [
      apiRoute,
      stream,
      processStreamResponse,
      processNonStreamResponse,
      updateMessages,
      onConnect,
      onError,
      getMessagesToSend
    ]
  );
  const handleSubmit = (0, import_react.useCallback)(
    (event, options = {}) => {
      var _a;
      (_a = event == null ? void 0 : event.preventDefault) == null ? void 0 : _a.call(event);
      const currentInput = input.trim();
      setInput("");
      return sendRequest(currentInput, options);
    },
    [input, sendRequest]
  );
  const handleInputChange = (0, import_react.useCallback)(
    (e) => {
      setInput(e.target.value);
    },
    []
  );
  const sendMessage = (0, import_react.useCallback)(
    async (content, options = {}) => {
      await sendRequest(content.trim(), options);
    },
    [sendRequest]
  );
  const regenerate = (0, import_react.useCallback)(
    async (options = {}) => {
      const lastUserMessage = messagesRef.current.findLast(
        (m) => m.role === "user"
      );
      if (!lastUserMessage) return;
      await sendRequest(lastUserMessage.content, options);
    },
    [sendRequest]
  );
  const stop = (0, import_react.useCallback)(() => {
    var _a;
    (_a = abortControllerRef.current) == null ? void 0 : _a.abort();
    setIsLoading(false);
  }, []);
  const processErrorResponse = async (response) => {
    const res = await response.json();
    if (res.error.error) {
      throw new Error(res.error.error.message);
    } else {
      throw new Error("Failed to send message");
    }
  };
  return (0, import_react.useMemo)(
    () => ({
      messages,
      input,
      handleInputChange,
      handleSubmit,
      isLoading,
      error,
      regenerate,
      stop,
      setMessages: updateMessages,
      threadId: threadIdRef.current,
      sendMessage,
      setInput,
      setThreadId
    }),
    [
      messages,
      input,
      handleInputChange,
      handleSubmit,
      isLoading,
      error,
      regenerate,
      stop,
      updateMessages,
      sendMessage
    ]
  );
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  usePipe
});
//# sourceMappingURL=index.js.map