@absolutejs/absolute 0.19.0-beta.225 → 0.19.0-beta.227

package/dist/ai-client/vue/ai/index.js

@@ -0,0 +1,460 @@
+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;
+};
+
+// src/vue/ai/useAIStream.ts
+import { onUnmounted, ref, shallowRef } from "vue";
+
+// 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;
+  }
+};
+
+// types/typeGuards.ts
+var 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;
+  }
+};
+
+// 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/protocol.ts
+var generateId = () => crypto.randomUUID();
+
+// src/vue/ai/useAIStream.ts
+var AIStreamKey = Symbol("ai-stream");
+var useAIStream = (path, conversationId) => {
+  const connection = createAIConnection(path);
+  const store = createAIMessageStore();
+  const messages = shallowRef([]);
+  const isStreaming = ref(false);
+  const error = ref(null);
+  const activeConversationId = ref(conversationId ?? null);
+  let unsubscribeConnection = null;
+  let unsubscribeStore = null;
+  const syncState = () => {
+    const snapshot = store.getSnapshot();
+    const convId = activeConversationId.value ?? snapshot.activeConversationId;
+    const conversation = convId ? snapshot.conversations.get(convId) : undefined;
+    messages.value = conversation?.messages ?? [];
+    isStreaming.value = snapshot.isStreaming;
+    error.value = snapshot.error;
+    if (convId) {
+      activeConversationId.value = convId;
+    }
+  };
+  unsubscribeStore = store.subscribe(syncState);
+  unsubscribeConnection = connection.subscribe((msg) => {
+    const action = serverMessageToAction(msg);
+    if (action) {
+      store.dispatch(action);
+    }
+  });
+  const send = (content) => {
+    const convId = activeConversationId.value ?? generateId();
+    const msgId = generateId();
+    store.dispatch({
+      content,
+      conversationId: convId,
+      messageId: msgId,
+      type: "send"
+    });
+    connection.send({
+      content,
+      conversationId: convId,
+      type: "message"
+    });
+  };
+  const cancel = () => {
+    if (activeConversationId.value) {
+      store.dispatch({ type: "cancel" });
+      connection.send({
+        conversationId: activeConversationId.value,
+        type: "cancel"
+      });
+    }
+  };
+  const branch = (messageId, content) => {
+    if (activeConversationId.value) {
+      connection.send({
+        content,
+        conversationId: activeConversationId.value,
+        messageId,
+        type: "branch"
+      });
+    }
+  };
+  const destroy = () => {
+    unsubscribeConnection?.();
+    unsubscribeStore?.();
+    connection.close();
+  };
+  onUnmounted(destroy);
+  return {
+    branch,
+    cancel,
+    destroy,
+    error,
+    isStreaming,
+    messages,
+    send
+  };
+};
+export {
+  useAIStream,
+  AIStreamKey
+};