@absolutejs/ai 0.0.1

package/README.md

@@ -0,0 +1,6 @@
+# @absolutejs/ai
+
+Standalone AI runtime and provider package extracted from AbsoluteJS.
+
+This package currently focuses on generic AI/chat/provider functionality.
+RAG remains a separate package.

package/dist/ai/client/index.js

@@ -0,0 +1,682 @@
+// @bun
+// src/ai/client/actions.ts
+var serverMessageToAction = (message) => {
+  switch (message.type) {
+    case "chunk":
+      return {
+        content: message.content,
+        conversationId: message.conversationId,
+        messageId: message.messageId,
+        type: "chunk"
+      };
+    case "thinking":
+      return {
+        content: message.content,
+        conversationId: message.conversationId,
+        messageId: message.messageId,
+        type: "thinking"
+      };
+    case "tool_status":
+      return {
+        conversationId: message.conversationId,
+        input: message.input,
+        messageId: message.messageId,
+        name: message.name,
+        result: message.result,
+        status: message.status,
+        type: "tool_status"
+      };
+    case "image":
+      return {
+        conversationId: message.conversationId,
+        data: message.data,
+        format: message.format,
+        imageId: message.imageId,
+        isPartial: message.isPartial,
+        messageId: message.messageId,
+        revisedPrompt: message.revisedPrompt,
+        type: "image"
+      };
+    case "complete":
+      return {
+        conversationId: message.conversationId,
+        durationMs: message.durationMs,
+        messageId: message.messageId,
+        model: message.model,
+        sources: message.sources,
+        type: "complete",
+        usage: message.usage
+      };
+    case "rag_retrieving":
+      return {
+        conversationId: message.conversationId,
+        messageId: message.messageId,
+        retrievalStartedAt: message.retrievalStartedAt,
+        type: "rag_retrieving"
+      };
+    case "rag_retrieved":
+      return {
+        conversationId: message.conversationId,
+        messageId: message.messageId,
+        retrievalDurationMs: message.retrievalDurationMs,
+        retrievalStartedAt: message.retrievalStartedAt,
+        retrievedAt: message.retrievedAt,
+        sources: message.sources,
+        trace: message.trace,
+        type: "rag_retrieved"
+      };
+    case "error":
+      return { message: message.message, type: "error" };
+    default:
+      return null;
+  }
+};
+// 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;
+  }
+};
+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":
+    case "thinking":
+      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 "image":
+      return "data" in data && typeof data.data === "string" && "format" in data && typeof data.format === "string" && "isPartial" in data && typeof data.isPartial === "boolean" && "messageId" in data && "conversationId" in data;
+    case "complete":
+      return "messageId" in data && "conversationId" in data;
+    case "rag_retrieved":
+      return "conversationId" in data && "messageId" in data && "sources" in data && Array.isArray(data.sources);
+    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,
+    pendingMessages: [],
+    pingInterval: null,
+    reconnectAttempts: 0,
+    reconnectTimeout: null,
+    ws: null
+  };
+  const flushPendingMessages = () => {
+    if (connState.ws?.readyState !== WS_OPEN) {
+      return;
+    }
+    while (connState.pendingMessages.length > 0) {
+      const next = connState.pendingMessages.shift();
+      if (typeof next === "string") {
+        connState.ws.send(next);
+      }
+    }
+  };
+  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;
+      flushPendingMessages();
+      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) => {
+    const serialized = JSON.stringify(msg);
+    if (connState.ws?.readyState === WS_OPEN) {
+      connState.ws.send(serialized);
+      return;
+    }
+    connState.pendingMessages.push(serialized);
+  };
+  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 = {
+      createdAt: Date.now(),
+      id: conversationId,
+      messages: []
+    };
+    state.conversations.set(conversationId, conversation);
+  }
+  return conversation;
+};
+var handleSend = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = {
+    attachments: action.attachments,
+    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 existingIdx = conversation.messages.findIndex((msg) => msg.id === action.messageId && msg.role === "assistant");
+  if (existingIdx >= 0) {
+    const prevContent = conversation.messages[existingIdx]?.content ?? "";
+    conversation.messages = conversation.messages.map((msg, idx) => idx === existingIdx ? { ...msg, content: prevContent + action.content } : msg);
+    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 handleThinking = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const existingIdx = conversation.messages.findIndex((msg) => msg.id === action.messageId && msg.role === "assistant");
+  if (existingIdx >= 0) {
+    const prevThinking = conversation.messages[existingIdx]?.thinking ?? "";
+    conversation.messages = conversation.messages.map((msg, idx) => idx === existingIdx ? { ...msg, thinking: prevThinking + action.content } : msg);
+    return;
+  }
+  const message = {
+    content: "",
+    conversationId: action.conversationId,
+    id: action.messageId,
+    isStreaming: true,
+    role: "assistant",
+    thinking: action.content,
+    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 getOrCreateAssistantMessage = (conversation, messageId, conversationId) => {
+  const existing = findAssistantMessage(conversation, messageId);
+  if (existing) {
+    return existing;
+  }
+  const message = {
+    content: "",
+    conversationId,
+    id: messageId,
+    isStreaming: true,
+    role: "assistant",
+    timestamp: Date.now()
+  };
+  conversation.messages = [...conversation.messages, message];
+  return message;
+};
+var handleRAGRetrieved = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = getOrCreateAssistantMessage(conversation, action.messageId, action.conversationId);
+  message.sources = action.sources;
+  message.retrievalStartedAt = action.retrievalStartedAt ?? message.retrievalStartedAt;
+  message.retrievedAt = action.retrievedAt;
+  message.retrievalDurationMs = action.retrievalDurationMs;
+  message.retrievalTrace = action.trace;
+  conversation.messages = [...conversation.messages];
+};
+var handleRAGRetrieving = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = getOrCreateAssistantMessage(conversation, action.messageId, action.conversationId);
+  message.retrievalStartedAt = action.retrievalStartedAt;
+  conversation.messages = [...conversation.messages];
+};
+var handleToolStatus = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = getOrCreateAssistantMessage(conversation, action.messageId, action.conversationId);
+  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, usage, durationMs, model, sources) => {
+  conversation.messages = conversation.messages.map((msg) => msg.id === messageId && msg.role === "assistant" ? {
+    ...msg,
+    durationMs,
+    isStreaming: false,
+    model,
+    sources: sources ?? msg.sources,
+    usage
+  } : msg);
+};
+var NOT_FOUND = -1;
+var findExistingImageById = (images, imageId) => {
+  if (!imageId)
+    return NOT_FOUND;
+  return images.findIndex((img) => img.imageId === imageId);
+};
+var findReplaceablePartialIndex = (images) => {
+  const lastIdx = images.length - 1;
+  if (lastIdx >= 0 && images[lastIdx]?.isPartial) {
+    return lastIdx;
+  }
+  return NOT_FOUND;
+};
+var upsertImage = (message, imageData) => {
+  if (!message.images) {
+    message.images = [imageData];
+    return;
+  }
+  const existingIdx = findExistingImageById(message.images, imageData.imageId);
+  if (existingIdx >= 0) {
+    message.images[existingIdx] = imageData;
+    return;
+  }
+  const replaceableIdx = findReplaceablePartialIndex(message.images);
+  if (replaceableIdx >= 0) {
+    message.images[replaceableIdx] = imageData;
+    return;
+  }
+  message.images = [...message.images, imageData];
+};
+var handleImage = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = getOrCreateAssistantMessage(conversation, action.messageId, action.conversationId);
+  upsertImage(message, {
+    data: action.data,
+    format: action.format,
+    imageId: action.imageId,
+    isPartial: action.isPartial,
+    revisedPrompt: action.revisedPrompt
+  });
+  conversation.messages = [...conversation.messages];
+};
+var handleComplete = (state, action) => {
+  const conversation = state.conversations.get(action.conversationId);
+  if (conversation) {
+    markMessageComplete(conversation, action.messageId, action.usage, action.durationMs, action.model, action.sources);
+  }
+  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 = {
+    createdAt: Date.now(),
+    id: action.newConversationId,
+    messages: branchedMessages
+  };
+  state.conversations.set(action.newConversationId, newConversation);
+  state.activeConversationId = action.newConversationId;
+};
+var applyAction = (state, action) => {
+  switch (action.type) {
+    case "send":
+      handleSend(state, action);
+      break;
+    case "chunk":
+      handleChunk(state, action);
+      break;
+    case "thinking":
+      handleThinking(state, action);
+      break;
+    case "tool_status":
+      handleToolStatus(state, action);
+      break;
+    case "image":
+      handleImage(state, action);
+      break;
+    case "complete":
+      handleComplete(state, action);
+      break;
+    case "error":
+      state.error = action.message;
+      state.isStreaming = false;
+      break;
+    case "rag_retrieving":
+      handleRAGRetrieving(state, action);
+      break;
+    case "rag_retrieved":
+      handleRAGRetrieved(state, action);
+      break;
+    case "cancel":
+      state.isStreaming = false;
+      markAllStreamsComplete(state);
+      break;
+    case "branch":
+      handleBranch(state, action);
+      break;
+    case "set_conversation":
+      state.activeConversationId = action.conversationId;
+      break;
+  }
+};
+var createAIMessageStore = () => {
+  let state = freshState();
+  const subscribers = new Set;
+  return {
+    dispatch: (action) => {
+      applyAction(state, action);
+      state = { ...state, conversations: new Map(state.conversations) };
+      subscribers.forEach((callback) => callback());
+    },
+    getServerSnapshot: () => EMPTY_STATE,
+    getSnapshot: () => state,
+    subscribe: (callback) => {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+      };
+    }
+  };
+};
+
+// 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 = (message) => JSON.stringify(message);
+
+// src/ai/client/createAIStream.ts
+var createAIStream = (path, conversationId) => {
+  const connection = createAIConnection(path);
+  const store = createAIMessageStore();
+  const listeners = new Set;
+  let currentError = null;
+  let currentIsStreaming = false;
+  let currentMessages = [];
+  let activeConversationId = conversationId ?? null;
+  const syncState = () => {
+    const snapshot = store.getSnapshot();
+    const convId = activeConversationId ?? snapshot.activeConversationId;
+    const conversation = convId ? snapshot.conversations.get(convId) : undefined;
+    activeConversationId = convId ?? snapshot.activeConversationId;
+    currentError = snapshot.error;
+    currentIsStreaming = snapshot.isStreaming;
+    currentMessages = conversation?.messages ?? [];
+    listeners.forEach((listener) => listener());
+  };
+  const unsubscribeStore = store.subscribe(syncState);
+  const unsubscribeConnection = connection.subscribe((message) => {
+    const action = serverMessageToAction(message);
+    if (action) {
+      store.dispatch(action);
+    }
+  });
+  const branch = (messageId, content) => {
+    if (activeConversationId) {
+      connection.send({
+        content,
+        conversationId: activeConversationId,
+        messageId,
+        type: "branch"
+      });
+    }
+  };
+  const cancel = () => {
+    if (activeConversationId) {
+      store.dispatch({ type: "cancel" });
+      connection.send({
+        conversationId: activeConversationId,
+        type: "cancel"
+      });
+    }
+  };
+  const destroy = () => {
+    unsubscribeStore();
+    unsubscribeConnection();
+    connection.close();
+    listeners.clear();
+  };
+  const send = (content, attachments) => {
+    const convId = activeConversationId ?? generateId();
+    const msgId = generateId();
+    store.dispatch({
+      attachments,
+      content,
+      conversationId: convId,
+      messageId: msgId,
+      type: "send"
+    });
+    connection.send({
+      attachments,
+      content,
+      conversationId: convId,
+      type: "message"
+    });
+  };
+  const subscribe = (callback) => {
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+    };
+  };
+  return {
+    branch,
+    cancel,
+    destroy,
+    send,
+    subscribe,
+    get error() {
+      return currentError;
+    },
+    get isStreaming() {
+      return currentIsStreaming;
+    },
+    get messages() {
+      return currentMessages;
+    }
+  };
+};
+export {
+  serverMessageToAction,
+  createAIStream,
+  createAIConnection
+};
+
+//# debugId=D06BB75544A02DB464756E2164756E21
+//# sourceMappingURL=index.js.map