@absolutejs/ai 0.0.45 → 0.0.47

package/dist/ai/index.js

@@ -2259,6 +2259,115 @@ var createMemoryStore = () => {
   return { get, getOrCreate, list, remove, set };
 };
 
+// src/ai/client/turnQueue.ts
+var DEFAULT_MAX_SIZE = 100;
+
+class ConversationTurnQueueFullError extends Error {
+  constructor(maxSize) {
+    super(`Conversation turn queue is full (${maxSize} items)`);
+    this.name = "ConversationTurnQueueFullError";
+  }
+}
+var createConversationTurnQueue = (options) => {
+  const maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
+  const items = [];
+  const listeners = new Set;
+  let activeAbort = null;
+  let draining = false;
+  const snapshot2 = () => ({
+    items: items.map((item) => ({ ...item })),
+    running: items.some(({ status }) => status === "running")
+  });
+  const notify = () => {
+    const next = snapshot2();
+    listeners.forEach((listener) => listener(next));
+  };
+  const drain = async () => {
+    if (draining)
+      return;
+    const next = items.find(({ status }) => status === "queued");
+    if (!next || items.some(({ status }) => status === "failed"))
+      return;
+    draining = true;
+    next.status = "running";
+    activeAbort = new AbortController;
+    notify();
+    try {
+      await options.execute(next.input, {
+        id: next.id,
+        signal: activeAbort.signal
+      });
+      const index = items.findIndex(({ id }) => id === next.id);
+      if (index >= 0)
+        items.splice(index, 1);
+    } catch (error) {
+      if (activeAbort.signal.aborted) {
+        const index = items.findIndex(({ id }) => id === next.id);
+        if (index >= 0)
+          items.splice(index, 1);
+      } else {
+        next.error = error;
+        next.status = "failed";
+        options.onError?.(error, { ...next });
+      }
+    } finally {
+      activeAbort = null;
+      draining = false;
+      notify();
+      drain();
+    }
+  };
+  const enqueue = (input, id = crypto.randomUUID()) => {
+    if (items.length >= maxSize) {
+      throw new ConversationTurnQueueFullError(maxSize);
+    }
+    items.push({ id, input, status: "queued" });
+    notify();
+    drain();
+    return id;
+  };
+  const remove = (id) => {
+    const index = items.findIndex((item) => item.id === id && item.status !== "running");
+    if (index < 0)
+      return false;
+    items.splice(index, 1);
+    notify();
+    drain();
+    return true;
+  };
+  const retry = (id) => {
+    const item = items.find((candidate) => candidate.id === id && candidate.status === "failed");
+    if (!item)
+      return false;
+    delete item.error;
+    item.status = "queued";
+    notify();
+    drain();
+    return true;
+  };
+  const cancel = (input = {}) => {
+    activeAbort?.abort();
+    if (input.clearPending) {
+      for (let index = items.length - 1;index >= 0; index--) {
+        if (items[index]?.status !== "running")
+          items.splice(index, 1);
+      }
+    }
+    notify();
+  };
+  return {
+    cancel,
+    enqueue,
+    getSnapshot: snapshot2,
+    remove,
+    retry,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+};
+
 // types/typeGuards.ts
 var isValidAIClientMessage = (data) => {
   if (!data || typeof data !== "object") {
@@ -2295,6 +2404,12 @@ var isValidAIServerMessage = (data) => {
       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 "turn_queued":
+      return "conversationId" in data && typeof data.conversationId === "string" && "messageId" in data && typeof data.messageId === "string" && "position" in data && typeof data.position === "number";
+    case "turn_started":
+      return "conversationId" in data && typeof data.conversationId === "string" && "messageId" in data && typeof data.messageId === "string";
+    case "branched":
+      return "content" in data && typeof data.content === "string" && "fromMessageId" in data && typeof data.fromMessageId === "string" && "messageId" in data && typeof data.messageId === "string" && "newConversationId" in data && typeof data.newConversationId === "string" && "oldConversationId" in data && typeof data.oldConversationId === "string";
     case "rag_retrieved":
       return "conversationId" in data && "messageId" in data && "sources" in data && Array.isArray(data.sources);
     case "error":
@@ -3210,14 +3325,20 @@ var aiChat = (config2) => {
   const store = config2.store ?? createMemoryStore();
   const parseProvider = config2.parseProvider ?? defaultParseProvider;
   const abortControllers = new Map;
+  const turnQueues = new Map;
+  const sendServerEvent = (ws, event) => {
+    if (ws.readyState === 1)
+      ws.send(JSON.stringify(event));
+  };
   const handleCancel = (conversationId) => {
+    turnQueues.get(conversationId)?.cancel({ clearPending: true });
     const controller = abortControllers.get(conversationId);
     if (controller) {
       controller.abort();
       abortControllers.delete(conversationId);
     }
   };
-  const handleBranch = async (ws, messageId, conversationId) => {
+  const handleBranch = async (ws, messageId, conversationId, content) => {
     const source = await store.get(conversationId);
     if (!source) {
       return;
@@ -3225,55 +3346,123 @@ var aiChat = (config2) => {
     const newConv = branchConversation(source, messageId);
     if (newConv) {
       await store.set(newConv.id, newConv);
-      ws.send(JSON.stringify({ conversationId: newConv.id, type: "branched" }));
+      const clientMessageId = generateId();
+      sendServerEvent(ws, {
+        content,
+        fromMessageId: messageId,
+        messageId: clientMessageId,
+        newConversationId: newConv.id,
+        oldConversationId: conversationId,
+        type: "branched"
+      });
+      enqueueUserMessage({
+        clientMessageId,
+        content,
+        conversationId: newConv.id,
+        ws
+      });
     }
   };
-  const handleUserMessage = async (ws, rawContent, rawConversationId, attachments) => {
-    const conversationId = rawConversationId ?? generateId();
-    const messageId = generateId();
+  const handleUserMessage = async (ws, rawContent, conversationId, clientMessageId, attachments, queueSignal) => {
+    const assistantMessageId = generateId();
     const parsed = parseProvider(rawContent);
     const { content, providerName } = parsed;
     const conversation = await store.getOrCreate(conversationId);
     const history = getHistory(conversation);
     const controller = new AbortController;
     abortControllers.set(conversationId, controller);
+    const abortFromQueue = () => controller.abort();
+    queueSignal?.addEventListener("abort", abortFromQueue, { once: true });
     appendMessage(conversation, {
       attachments,
       content,
       conversationId,
-      id: messageId,
+      id: clientMessageId,
       role: "user",
       timestamp: Date.now()
     });
     await store.set(conversationId, conversation);
     const model = resolveModel(config2, parsed);
     const userMessage = buildUserMessage(content, attachments);
-    await streamAI(ws, conversationId, messageId, {
-      maxTurns: config2.maxTurns,
-      messages: [...history, userMessage],
-      model,
-      provider: config2.provider(providerName),
-      signal: controller.signal,
-      systemPrompt: config2.systemPrompt,
-      reasoning: resolveReasoning(config2, providerName, model),
-      tools: resolveTools(config2, providerName, model),
-      onComplete: async (fullResponse, usage) => {
-        const conv = await store.get(conversationId);
-        if (conv) {
-          appendMessage(conv, {
-            content: fullResponse,
-            conversationId,
-            id: generateId(),
-            role: "assistant",
-            timestamp: Date.now()
-          });
-          await store.set(conversationId, conv);
+    try {
+      await streamAI(ws, conversationId, assistantMessageId, {
+        maxTurns: config2.maxTurns,
+        messages: [...history, userMessage],
+        model,
+        provider: config2.provider(providerName),
+        signal: controller.signal,
+        systemPrompt: config2.systemPrompt,
+        reasoning: resolveReasoning(config2, providerName, model),
+        tools: resolveTools(config2, providerName, model),
+        onComplete: async (fullResponse, usage) => {
+          const conv = await store.get(conversationId);
+          if (conv) {
+            appendMessage(conv, {
+              content: fullResponse,
+              conversationId,
+              id: assistantMessageId,
+              role: "assistant",
+              timestamp: Date.now()
+            });
+            await store.set(conversationId, conv);
+          }
+          config2.onComplete?.(conversationId, fullResponse, usage);
         }
+      });
+    } finally {
+      queueSignal?.removeEventListener("abort", abortFromQueue);
+      if (abortControllers.get(conversationId) === controller) {
         abortControllers.delete(conversationId);
-        config2.onComplete?.(conversationId, fullResponse, usage);
+      }
+    }
+  };
+  const queueForConversation = (conversationId) => {
+    const existing = turnQueues.get(conversationId);
+    if (existing)
+      return existing;
+    const queue = createConversationTurnQueue({
+      execute: async (turn, { signal }) => {
+        sendServerEvent(turn.ws, {
+          conversationId: turn.conversationId,
+          messageId: turn.clientMessageId,
+          type: "turn_started"
+        });
+        await handleUserMessage(turn.ws, turn.content, turn.conversationId, turn.clientMessageId, turn.attachments, signal);
+      },
+      onError: (error, turn) => {
+        sendServerEvent(turn.input.ws, {
+          message: error instanceof Error ? error.message : "AI turn failed",
+          type: "error"
+        });
+      }
+    });
+    turnQueues.set(conversationId, queue);
+    let unsubscribe = () => {
+      return;
+    };
+    unsubscribe = queue.subscribe(({ items }) => {
+      if (items.length === 0 && turnQueues.get(conversationId) === queue) {
+        turnQueues.delete(conversationId);
+        unsubscribe();
       }
     });
+    return queue;
   };
+  function enqueueUserMessage(turn) {
+    const queue = queueForConversation(turn.conversationId);
+    const wasBusy = queue.getSnapshot().items.length > 0;
+    queue.enqueue(turn, turn.clientMessageId);
+    if (wasBusy) {
+      const queued = queue.getSnapshot().items.filter(({ status }) => status === "queued");
+      const position = queued.findIndex(({ id }) => id === turn.clientMessageId) + 1;
+      sendServerEvent(turn.ws, {
+        conversationId: turn.conversationId,
+        messageId: turn.clientMessageId,
+        position,
+        type: "turn_queued"
+      });
+    }
+  }
   const htmxRoutes = () => {
     if (!config2.htmx) {
       return new Elysia;
@@ -3366,11 +3555,18 @@ var aiChat = (config2) => {
         return;
       }
       if (msg.type === "branch") {
-        await handleBranch(ws, msg.messageId, msg.conversationId);
+        await handleBranch(ws, msg.messageId, msg.conversationId, msg.content);
         return;
       }
       if (msg.type === "message") {
-        await handleUserMessage(ws, msg.content, msg.conversationId, msg.attachments);
+        const conversationId = msg.conversationId ?? generateId();
+        enqueueUserMessage({
+          attachments: msg.attachments,
+          clientMessageId: msg.messageId ?? generateId(),
+          content: msg.content,
+          conversationId,
+          ws
+        });
       }
     }
   }).get(`${path}/conversations`, () => store.list()).get(`${path}/conversations/:id`, async ({ params }) => {
@@ -5202,6 +5398,28 @@ var serverMessageToAction = (message) => {
         type: "complete",
         usage: message.usage
       };
+    case "turn_queued":
+      return {
+        conversationId: message.conversationId,
+        messageId: message.messageId,
+        position: message.position,
+        type: "turn_queued"
+      };
+    case "turn_started":
+      return {
+        conversationId: message.conversationId,
+        messageId: message.messageId,
+        type: "turn_started"
+      };
+    case "branched":
+      return {
+        content: message.content,
+        fromMessageId: message.fromMessageId,
+        messageId: message.messageId,
+        newConversationId: message.newConversationId,
+        oldConversationId: message.oldConversationId,
+        type: "branch"
+      };
     case "rag_retrieving":
       return {
         conversationId: message.conversationId,
@@ -5403,6 +5621,7 @@ var handleSend = (state, action) => {
     content: action.content,
     conversationId: action.conversationId,
     id: action.messageId,
+    isQueued: false,
     role: "user",
     timestamp: Date.now()
   };
@@ -5411,6 +5630,19 @@ var handleSend = (state, action) => {
   state.error = null;
   state.isStreaming = true;
 };
+var updateUserQueueState = (state, conversationId, messageId, isQueued) => {
+  const conversation = state.conversations.get(conversationId);
+  if (!conversation)
+    return;
+  conversation.messages = conversation.messages.map((message) => message.id === messageId && message.role === "user" ? { ...message, isQueued } : message);
+};
+var handleTurnQueued = (state, action) => {
+  updateUserQueueState(state, action.conversationId, action.messageId, true);
+};
+var handleTurnStarted = (state, action) => {
+  updateUserQueueState(state, action.conversationId, action.messageId, false);
+  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");
@@ -5591,10 +5823,21 @@ var handleBranch = (state, action) => {
   const newConversation = {
     createdAt: Date.now(),
     id: action.newConversationId,
-    messages: branchedMessages
+    messages: [
+      ...branchedMessages,
+      {
+        content: action.content,
+        conversationId: action.newConversationId,
+        id: action.messageId,
+        isQueued: false,
+        role: "user",
+        timestamp: Date.now()
+      }
+    ]
   };
   state.conversations.set(action.newConversationId, newConversation);
   state.activeConversationId = action.newConversationId;
+  state.isStreaming = true;
 };
 var applyAction = (state, action) => {
   switch (action.type) {
@@ -5616,6 +5859,12 @@ var applyAction = (state, action) => {
     case "complete":
       handleComplete(state, action);
       break;
+    case "turn_queued":
+      handleTurnQueued(state, action);
+      break;
+    case "turn_started":
+      handleTurnStarted(state, action);
+      break;
     case "error":
       state.error = action.message;
       state.isStreaming = false;
@@ -5723,6 +5972,7 @@ var createAIStream = (path, conversationId) => {
       attachments,
       content,
       conversationId: convId,
+      messageId: msgId,
       type: "message"
     });
   };
@@ -5999,5 +6249,5 @@ export {
   BUILTIN_UI_CARDS
 };
 
-//# debugId=4DB8BD5EBB62E6E464756E2164756E21
+//# debugId=79EC11089E8CB24964756E2164756E21
 //# sourceMappingURL=index.js.map