ai 3.1.8 → 3.1.10

package/svelte/dist/index.mjs

@@ -1591,7 +1591,158 @@ function useCompletion({
     data: streamData
   };
 }
+
+// svelte/use-assistant.ts
+import { isAbortError } from "@ai-sdk/provider-utils";
+import { get as get3, writable as writable3 } from "svelte/store";
+var uniqueId3 = 0;
+var store3 = {};
+function useAssistant({
+  api,
+  threadId: threadIdParam,
+  credentials,
+  headers,
+  body,
+  onError
+}) {
+  const threadIdStore = writable3(threadIdParam);
+  const key = `${api}|${threadIdParam != null ? threadIdParam : `completion-${uniqueId3++}`}`;
+  const messages = writable3(store3[key] || []);
+  const input = writable3("");
+  const status = writable3("awaiting_message");
+  const error = writable3(void 0);
+  let abortController = null;
+  const mutateMessages = (newMessages) => {
+    store3[key] = newMessages;
+    messages.set(newMessages);
+  };
+  async function append(message, requestOptions) {
+    var _a, _b, _c, _d;
+    status.set("in_progress");
+    abortController = new AbortController();
+    mutateMessages([
+      ...get3(messages),
+      { ...message, id: (_a = message.id) != null ? _a : generateId() }
+    ]);
+    input.set("");
+    try {
+      const result = await fetch(api, {
+        method: "POST",
+        credentials,
+        signal: abortController.signal,
+        headers: { "Content-Type": "application/json", ...headers },
+        body: JSON.stringify({
+          ...body,
+          // always use user-provided threadId when available:
+          threadId: (_b = threadIdParam != null ? threadIdParam : get3(threadIdStore)) != null ? _b : null,
+          message: message.content,
+          // optional request data:
+          data: requestOptions == null ? void 0 : requestOptions.data
+        })
+      });
+      if (result.body == null) {
+        throw new Error("The response body is empty.");
+      }
+      for await (const { type, value } of readDataStream(
+        result.body.getReader()
+      )) {
+        switch (type) {
+          case "assistant_message": {
+            mutateMessages([
+              ...get3(messages),
+              {
+                id: value.id,
+                role: value.role,
+                content: value.content[0].text.value
+              }
+            ]);
+            break;
+          }
+          case "text": {
+            mutateMessages(
+              get3(messages).map((msg, index, array) => {
+                if (index === array.length - 1) {
+                  return { ...msg, content: msg.content + value };
+                }
+                return msg;
+              })
+            );
+            break;
+          }
+          case "data_message": {
+            mutateMessages([
+              ...get3(messages),
+              {
+                id: (_c = value.id) != null ? _c : generateId(),
+                role: "data",
+                content: "",
+                data: value.data
+              }
+            ]);
+            break;
+          }
+          case "assistant_control_data": {
+            threadIdStore.set(value.threadId);
+            mutateMessages(
+              get3(messages).map((msg, index, array) => {
+                if (index === array.length - 1) {
+                  return { ...msg, id: value.messageId };
+                }
+                return msg;
+              })
+            );
+            break;
+          }
+          case "error": {
+            error.set(new Error(value));
+            break;
+          }
+        }
+      }
+    } catch (err) {
+      if (isAbortError(error) && ((_d = abortController == null ? void 0 : abortController.signal) == null ? void 0 : _d.aborted)) {
+        abortController = null;
+        return;
+      }
+      if (onError && err instanceof Error) {
+        onError(err);
+      }
+      error.set(err);
+    } finally {
+      abortController = null;
+      status.set("awaiting_message");
+    }
+  }
+  function setMessages(messages2) {
+    mutateMessages(messages2);
+  }
+  function stop() {
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+  }
+  async function submitMessage(e, requestOptions) {
+    e.preventDefault();
+    const inputValue = get3(input);
+    if (!inputValue)
+      return;
+    await append({ role: "user", content: inputValue }, requestOptions);
+  }
+  return {
+    messages,
+    error,
+    threadId: threadIdStore,
+    input,
+    append,
+    submitMessage,
+    status,
+    setMessages,
+    stop
+  };
+}
 export {
+  useAssistant,
   useChat,
   useCompletion
 };