@absolutejs/absolute 0.19.0-beta.226 → 0.19.0-beta.228

package/dist/react/ai/index.js

@@ -0,0 +1,635 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// types/typeGuards.ts
+var isValidAIClientMessage = (data) => {
+  if (!data || typeof data !== "object") {
+    return false;
+  }
+  if (!("type" in data) || typeof data.type !== "string") {
+    return false;
+  }
+  switch (data.type) {
+    case "message":
+      return "content" in data && typeof data.content === "string";
+    case "cancel":
+      return "conversationId" in data && typeof data.conversationId === "string";
+    case "branch":
+      return "messageId" in data && typeof data.messageId === "string" && "content" in data && typeof data.content === "string" && "conversationId" in data && typeof data.conversationId === "string";
+    default:
+      return false;
+  }
+}, isValidAIServerMessage = (data) => {
+  if (!data || typeof data !== "object") {
+    return false;
+  }
+  if (!("type" in data) || typeof data.type !== "string") {
+    return false;
+  }
+  switch (data.type) {
+    case "chunk":
+      return "content" in data && typeof data.content === "string" && "messageId" in data && "conversationId" in data;
+    case "tool_status":
+      return "name" in data && "status" in data && "messageId" in data && "conversationId" in data;
+    case "complete":
+      return "messageId" in data && "conversationId" in data;
+    case "error":
+      return "message" in data && typeof data.message === "string";
+    default:
+      return false;
+  }
+}, isValidHMRClientMessage = (data) => {
+  if (!data || typeof data !== "object") {
+    return false;
+  }
+  if (!("type" in data) || typeof data.type !== "string") {
+    return false;
+  }
+  switch (data.type) {
+    case "ping":
+      return true;
+    case "ready":
+      return true;
+    case "request-rebuild":
+      return true;
+    case "hydration-error":
+      return true;
+    case "hmr-timing":
+      return true;
+    default:
+      return false;
+  }
+};
+
+// src/react/ai/AIStreamProvider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useRef
+} from "react";
+
+// src/ai/client/connection.ts
+var WS_OPEN = 1;
+var WS_NORMAL_CLOSURE = 1000;
+var WS_CLOSED = 3;
+var DEFAULT_PING_INTERVAL = 30000;
+var RECONNECT_INITIAL_DELAY = 500;
+var RECONNECT_POLL_INTERVAL = 300;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 60;
+var noop = () => {};
+var noopUnsubscribe = () => noop;
+var NOOP_CONNECTION = {
+  close: noop,
+  send: noop,
+  subscribe: noopUnsubscribe,
+  getReadyState: () => WS_CLOSED
+};
+var buildWsUrl = (path) => {
+  const { hostname, port, protocol } = window.location;
+  const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
+  const portSuffix = port ? `:${port}` : "";
+  return `${wsProtocol}//${hostname}${portSuffix}${path}`;
+};
+var parseServerMessage = (event) => {
+  let data;
+  try {
+    data = JSON.parse(String(event.data));
+  } catch {
+    return null;
+  }
+  if (data && typeof data === "object" && "type" in data && data.type === "pong") {
+    return null;
+  }
+  if (!isValidAIServerMessage(data)) {
+    return null;
+  }
+  return data;
+};
+var createAIConnection = (path, options = {}) => {
+  if (typeof window === "undefined") {
+    return NOOP_CONNECTION;
+  }
+  const shouldReconnect = options.reconnect !== false;
+  const pingInterval = options.pingInterval ?? DEFAULT_PING_INTERVAL;
+  const maxReconnectAttempts = options.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
+  const listeners = new Set;
+  const connState = {
+    isConnected: false,
+    pingInterval: null,
+    reconnectAttempts: 0,
+    reconnectTimeout: null,
+    ws: null
+  };
+  const clearTimers = () => {
+    if (connState.pingInterval) {
+      clearInterval(connState.pingInterval);
+      connState.pingInterval = null;
+    }
+    if (connState.reconnectTimeout) {
+      clearTimeout(connState.reconnectTimeout);
+      connState.reconnectTimeout = null;
+    }
+  };
+  const scheduleReconnect = () => {
+    connState.reconnectAttempts++;
+    const delay = connState.reconnectAttempts === 1 ? RECONNECT_INITIAL_DELAY : RECONNECT_POLL_INTERVAL;
+    connState.reconnectTimeout = setTimeout(() => {
+      if (connState.reconnectAttempts > maxReconnectAttempts) {
+        return;
+      }
+      connect();
+    }, delay);
+  };
+  const connect = () => {
+    const url = buildWsUrl(path);
+    const wsInstance = new WebSocket(url, options.protocols);
+    wsInstance.onopen = () => {
+      connState.isConnected = true;
+      connState.reconnectAttempts = 0;
+      connState.pingInterval = setInterval(() => {
+        if (wsInstance.readyState === WS_OPEN && connState.isConnected) {
+          wsInstance.send(JSON.stringify({ type: "ping" }));
+        }
+      }, pingInterval);
+    };
+    wsInstance.onmessage = (event) => {
+      const message = parseServerMessage(event);
+      if (!message) {
+        return;
+      }
+      listeners.forEach((listener) => listener(message));
+    };
+    wsInstance.onclose = (event) => {
+      connState.isConnected = false;
+      clearTimers();
+      const shouldAttemptReconnect = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && connState.reconnectAttempts < maxReconnectAttempts;
+      if (shouldAttemptReconnect) {
+        scheduleReconnect();
+      }
+    };
+    wsInstance.onerror = () => {};
+    connState.ws = wsInstance;
+  };
+  const send = (msg) => {
+    if (connState.ws?.readyState === WS_OPEN) {
+      connState.ws.send(JSON.stringify(msg));
+    }
+  };
+  const subscribe = (callback) => {
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+    };
+  };
+  const close = () => {
+    clearTimers();
+    if (connState.ws) {
+      connState.ws.close(WS_NORMAL_CLOSURE);
+      connState.ws = null;
+    }
+    connState.isConnected = false;
+    listeners.clear();
+  };
+  const getReadyState = () => connState.ws?.readyState ?? WS_CLOSED;
+  connect();
+  return { close, getReadyState, send, subscribe };
+};
+
+// src/ai/client/messageStore.ts
+var EMPTY_STATE = {
+  activeConversationId: null,
+  conversations: new Map,
+  error: null,
+  isStreaming: false
+};
+var initialActiveConversationId = null;
+var initialError = null;
+var freshState = () => ({
+  activeConversationId: initialActiveConversationId,
+  conversations: new Map,
+  error: initialError,
+  isStreaming: false
+});
+var findAssistantMessage = (conversation, messageId) => conversation.messages.find((msg) => msg.id === messageId && msg.role === "assistant");
+var getOrCreate = (state, conversationId) => {
+  let conversation = state.conversations.get(conversationId);
+  if (!conversation) {
+    conversation = { id: conversationId, messages: [] };
+    state.conversations.set(conversationId, conversation);
+  }
+  return conversation;
+};
+var handleSend = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = {
+    content: action.content,
+    conversationId: action.conversationId,
+    id: action.messageId,
+    role: "user",
+    timestamp: Date.now()
+  };
+  conversation.messages = [...conversation.messages, message];
+  state.activeConversationId = action.conversationId;
+  state.error = null;
+  state.isStreaming = true;
+};
+var handleChunk = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const existing = findAssistantMessage(conversation, action.messageId);
+  if (existing) {
+    existing.content += action.content;
+    conversation.messages = [...conversation.messages];
+    return;
+  }
+  const message = {
+    content: action.content,
+    conversationId: action.conversationId,
+    id: action.messageId,
+    isStreaming: true,
+    role: "assistant",
+    timestamp: Date.now()
+  };
+  conversation.messages = [...conversation.messages, message];
+};
+var upsertToolCall = (message, toolCall) => {
+  if (!message.toolCalls) {
+    message.toolCalls = [toolCall];
+    return;
+  }
+  const existingIdx = message.toolCalls.findIndex((existing) => existing.name === toolCall.name);
+  if (existingIdx >= 0) {
+    message.toolCalls[existingIdx] = toolCall;
+  } else {
+    message.toolCalls = [...message.toolCalls, toolCall];
+  }
+};
+var handleToolStatus = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = findAssistantMessage(conversation, action.messageId);
+  if (!message) {
+    return;
+  }
+  const toolCall = {
+    id: action.messageId,
+    input: action.input,
+    name: action.name,
+    result: action.status === "complete" ? action.result ?? "" : undefined
+  };
+  upsertToolCall(message, toolCall);
+  conversation.messages = [...conversation.messages];
+};
+var markMessageComplete = (conversation, messageId) => {
+  const message = findAssistantMessage(conversation, messageId);
+  if (message) {
+    message.isStreaming = false;
+  }
+  conversation.messages = [...conversation.messages];
+};
+var handleComplete = (state, action) => {
+  const conversation = state.conversations.get(action.conversationId);
+  if (conversation) {
+    markMessageComplete(conversation, action.messageId);
+  }
+  state.isStreaming = false;
+};
+var markConversationStreamsComplete = (conversation) => {
+  const streamingMessages = conversation.messages.filter((msg) => msg.isStreaming);
+  if (streamingMessages.length === 0) {
+    return;
+  }
+  for (const msg of streamingMessages) {
+    msg.isStreaming = false;
+  }
+  conversation.messages = [...conversation.messages];
+};
+var markAllStreamsComplete = (state) => {
+  for (const [, conversation] of state.conversations) {
+    markConversationStreamsComplete(conversation);
+  }
+};
+var handleBranch = (state, action) => {
+  const source = state.conversations.get(action.oldConversationId);
+  if (!source) {
+    return;
+  }
+  const cutoffIndex = source.messages.findIndex((msg) => msg.id === action.fromMessageId);
+  if (cutoffIndex < 0) {
+    return;
+  }
+  const branchedMessages = source.messages.slice(0, cutoffIndex + 1).map((msg) => ({ ...msg, conversationId: action.newConversationId }));
+  const newConversation = {
+    id: action.newConversationId,
+    messages: branchedMessages
+  };
+  state.conversations.set(action.newConversationId, newConversation);
+  state.activeConversationId = action.newConversationId;
+};
+var dispatch = (state, subscribers, action) => {
+  switch (action.type) {
+    case "send":
+      handleSend(state, action);
+      break;
+    case "chunk":
+      handleChunk(state, action);
+      break;
+    case "tool_status":
+      handleToolStatus(state, action);
+      break;
+    case "complete":
+      handleComplete(state, action);
+      break;
+    case "error":
+      state.error = action.message;
+      state.isStreaming = false;
+      break;
+    case "cancel":
+      state.isStreaming = false;
+      markAllStreamsComplete(state);
+      break;
+    case "branch":
+      handleBranch(state, action);
+      break;
+    case "set_conversation":
+      state.activeConversationId = action.conversationId;
+      break;
+  }
+  Object.assign(state, { conversations: new Map(state.conversations) });
+  subscribers.forEach((callback) => callback());
+};
+var createAIMessageStore = () => {
+  const state = freshState();
+  const subscribers = new Set;
+  return {
+    dispatch: (action) => dispatch(state, subscribers, action),
+    getServerSnapshot: () => EMPTY_STATE,
+    getSnapshot: () => state,
+    subscribe: (callback) => {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+      };
+    }
+  };
+};
+
+// src/ai/client/actions.ts
+var serverMessageToAction = (msg) => {
+  switch (msg.type) {
+    case "chunk":
+      return {
+        content: msg.content,
+        conversationId: msg.conversationId,
+        messageId: msg.messageId,
+        type: "chunk"
+      };
+    case "tool_status":
+      return {
+        conversationId: msg.conversationId,
+        input: msg.input,
+        messageId: msg.messageId,
+        name: msg.name,
+        result: msg.result,
+        status: msg.status,
+        type: "tool_status"
+      };
+    case "complete":
+      return {
+        conversationId: msg.conversationId,
+        messageId: msg.messageId,
+        type: "complete",
+        usage: msg.usage
+      };
+    case "error":
+      return { message: msg.message, type: "error" };
+    default:
+      return null;
+  }
+};
+
+// src/react/ai/AIStreamProvider.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+var AIStreamContext = createContext(null);
+var AIStreamProvider = ({
+  children,
+  path
+}) => {
+  const ref = useRef(null);
+  if (!ref.current) {
+    const connection = createAIConnection(path);
+    const store = createAIMessageStore();
+    ref.current = { connection, store };
+  }
+  useEffect(() => {
+    const { current } = ref;
+    if (!current) {
+      return;
+    }
+    const { connection, store } = current;
+    const unsubscribe = connection.subscribe((msg) => {
+      const action = serverMessageToAction(msg);
+      if (action) {
+        store.dispatch(action);
+      }
+    });
+    return () => {
+      unsubscribe();
+      connection.close();
+    };
+  }, []);
+  return /* @__PURE__ */ jsxDEV(AIStreamContext.Provider, {
+    value: ref.current,
+    children
+  }, undefined, false, undefined, this);
+};
+var useAIStreamContext = () => useContext(AIStreamContext);
+// src/react/ai/useAIStream.ts
+import { useCallback, useEffect as useEffect2, useRef as useRef2, useSyncExternalStore } from "react";
+
+// src/ai/protocol.ts
+var generateId = () => crypto.randomUUID();
+var parseAIMessage = (raw) => {
+  if (raw === null || raw === undefined) {
+    return null;
+  }
+  let text;
+  if (typeof raw === "string") {
+    text = raw;
+  } else if (raw instanceof ArrayBuffer) {
+    text = new TextDecoder().decode(raw);
+  } else if (ArrayBuffer.isView(raw)) {
+    text = new TextDecoder().decode(raw);
+  } else if (typeof raw === "object") {
+    if (isValidAIClientMessage(raw)) {
+      return raw;
+    }
+    return null;
+  } else {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (isValidAIClientMessage(parsed)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var serializeAIMessage = (msg) => JSON.stringify(msg);
+
+// src/react/ai/useAIStream.ts
+var useAIStream = (path, conversationId) => {
+  const context = useAIStreamContext();
+  const standaloneRef = useRef2(null);
+  const isStandalone = !context;
+  if (isStandalone && !standaloneRef.current && path) {
+    const connection2 = createAIConnection(path);
+    const store2 = createAIMessageStore();
+    standaloneRef.current = { connection: connection2, store: store2 };
+  }
+  const resolved = context ?? standaloneRef.current;
+  if (!resolved) {
+    throw new Error("useAIStream requires either an AIStreamProvider or a path argument");
+  }
+  const { connection, store } = resolved;
+  useEffect2(() => {
+    if (!isStandalone) {
+      return;
+    }
+    const unsubscribe = connection.subscribe((msg) => {
+      const action = serverMessageToAction(msg);
+      if (action) {
+        store.dispatch(action);
+      }
+    });
+    return () => {
+      unsubscribe();
+      connection.close();
+    };
+  }, [connection, isStandalone, store]);
+  const state = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot);
+  const activeConvId = conversationId ?? state.activeConversationId;
+  const conversation = activeConvId ? state.conversations.get(activeConvId) : undefined;
+  const messages = conversation?.messages ?? [];
+  const send = useCallback((content) => {
+    const convId = activeConvId ?? generateId();
+    const msgId = generateId();
+    store.dispatch({
+      content,
+      conversationId: convId,
+      messageId: msgId,
+      type: "send"
+    });
+    connection.send({
+      content,
+      conversationId: convId,
+      type: "message"
+    });
+  }, [activeConvId, connection, store]);
+  const cancel = useCallback(() => {
+    if (activeConvId) {
+      store.dispatch({ type: "cancel" });
+      connection.send({ conversationId: activeConvId, type: "cancel" });
+    }
+  }, [activeConvId, connection, store]);
+  const branch = useCallback((messageId, content) => {
+    if (activeConvId) {
+      connection.send({
+        content,
+        conversationId: activeConvId,
+        messageId,
+        type: "branch"
+      });
+    }
+  }, [activeConvId, connection]);
+  return {
+    branch,
+    cancel,
+    error: state.error,
+    isStreaming: state.isStreaming,
+    messages,
+    send
+  };
+};
+export {
+  useAIStream,
+  AIStreamProvider
+};
+
+//# debugId=64EEC7ABDA71D1BE64756E2164756E21
+//# sourceMappingURL=index.js.map