@absolutejs/ai 0.0.1 → 0.0.2

package/dist/react/ai/index.js

@@ -0,0 +1,736 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, name) => {
+  Object.defineProperty(target, "name", {
+    value: name,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+};
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== undefined && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length;i < n; i++)
+    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
+    get [name]() {
+      return __privateGet(this, extra);
+    },
+    set [name](x) {
+      __privateSet(this, extra, x);
+    }
+  }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1;i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => (name in x) };
+      if (k ^ 3)
+        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2)
+        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx);
+    done._ = 1;
+    if (k ^ 4 || it === undefined)
+      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null)
+      __typeError("Object expected");
+    else
+      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+
+// src/react/ai/AIStreamProvider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useRef
+} from "react";
+
+// 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":
+    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/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;
+  }
+};
+
+// 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((message) => {
+      const action = serverMessageToAction(message);
+      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();
+
+// 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((message) => {
+      const action = serverMessageToAction(message);
+      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, attachments) => {
+    const convId = activeConvId ?? generateId();
+    const msgId = generateId();
+    store.dispatch({
+      attachments,
+      content,
+      conversationId: convId,
+      messageId: msgId,
+      type: "send"
+    });
+    connection.send({
+      attachments,
+      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=70342D4BF2770C0F64756E2164756E21
+//# sourceMappingURL=index.js.map