@lunora/react 1.0.0-alpha.23 → 1.0.0-alpha.25

package/dist/packem_shared/useAgentChat-WPm5iHgR.mjs

@@ -0,0 +1,283 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useState, useRef } from 'react';
+import { useMutation } from './useMutation-BeqeIjTr.mjs';
+import { useStream } from './useStream-CGC26afa.mjs';
+import useSubscription from './useSubscription-D38Jdyr8.mjs';
+
+const NO_MUTATION_REF = {
+  __lunoraRef: ""
+};
+const NO_STREAM_REF = {
+  __lunoraRef: ""
+};
+const EMPTY_MESSAGES = [];
+const reconcileOptimistic = (optimistic, durable) => {
+  const pool = durable.filter((message) => message.role === "user").map((message) => message.content);
+  return optimistic.filter((pending) => {
+    const index = pool.indexOf(pending.content);
+    if (index !== -1) {
+      pool.splice(index, 1);
+      return false;
+    }
+    return true;
+  });
+};
+const useAgentChat = (options) => {
+  const $ = c(47);
+  const {
+    api,
+    cancel: cancelReference,
+    limit,
+    send: sendReference,
+    sendArgs,
+    stream: streamReference,
+    threadKey
+  } = options;
+  let t0;
+  if ($[0] !== limit || $[1] !== threadKey) {
+    t0 = limit === void 0 ? {
+      key: threadKey
+    } : {
+      key: threadKey,
+      limit
+    };
+    $[0] = limit;
+    $[1] = threadKey;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const messagesArguments = t0;
+  const {
+    data: history
+  } = useSubscription(api.agents.agentMessages, messagesArguments);
+  let t1;
+  if ($[3] !== threadKey) {
+    t1 = {
+      key: threadKey
+    };
+    $[3] = threadKey;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const {
+    data: threadData
+  } = useSubscription(api.agents.agentThread, t1);
+  let t2;
+  if ($[5] !== streamReference || $[6] !== threadKey) {
+    t2 = streamReference === void 0 ? "skip" : {
+      key: threadKey
+    };
+    $[5] = streamReference;
+    $[6] = threadKey;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  const streamArguments = t2;
+  const {
+    chunks
+  } = useStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const sendMutation = useMutation(sendReference);
+  const cancelMutation = useMutation(cancelReference ?? NO_MUTATION_REF);
+  const approvalMutation = useMutation(api.agents.agentResolveApproval);
+  let t3;
+  if ($[8] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t3 = [];
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  const [optimistic, setOptimistic] = useState(t3);
+  const nextIdRef = useRef(0);
+  const thread = threadData;
+  const status = thread?.status;
+  const instanceId = thread?.instanceId;
+  const durable = history ?? EMPTY_MESSAGES;
+  let t4;
+  if ($[9] !== durable || $[10] !== optimistic) {
+    const visibleOptimistic = reconcileOptimistic(optimistic, durable);
+    t4 = visibleOptimistic.length === 0 ? durable : [...durable, ...visibleOptimistic.map((pending, index) => ({
+      content: pending.content,
+      optimistic: true,
+      role: "user",
+      seq: durable.length + index
+    }))];
+    $[9] = durable;
+    $[10] = optimistic;
+    $[11] = t4;
+  } else {
+    t4 = $[11];
+  }
+  const messages = t4;
+  let t5;
+  if ($[12] !== durable) {
+    t5 = durable.filter(_temp);
+    $[12] = durable;
+    $[13] = t5;
+  } else {
+    t5 = $[13];
+  }
+  const assistantCount = t5.length;
+  let t6;
+  if ($[14] !== assistantCount || $[15] !== chunks || $[16] !== threadKey) {
+    let t72;
+    if ($[18] !== assistantCount || $[19] !== threadKey) {
+      t72 = (event) => event.kind !== "progress" && event.threadKey === threadKey && event.turn >= assistantCount;
+      $[18] = assistantCount;
+      $[19] = threadKey;
+      $[20] = t72;
+    } else {
+      t72 = $[20];
+    }
+    t6 = chunks.filter(t72).map(_temp2).join("");
+    $[14] = assistantCount;
+    $[15] = chunks;
+    $[16] = threadKey;
+    $[17] = t6;
+  } else {
+    t6 = $[17];
+  }
+  const streamingText = t6;
+  const {
+    mutate: sendMutate
+  } = sendMutation;
+  const {
+    mutate: cancelMutate
+  } = cancelMutation;
+  const {
+    mutate: resolveMutate
+  } = approvalMutation;
+  let t7;
+  if ($[21] !== durable || $[22] !== sendArgs || $[23] !== sendMutate || $[24] !== threadKey) {
+    t7 = async (input, args) => {
+      const id = nextIdRef.current;
+      nextIdRef.current = nextIdRef.current + 1;
+      setOptimistic((previous) => [...reconcileOptimistic(previous, durable), {
+        content: input,
+        id
+      }]);
+      try {
+        await sendMutate({
+          input,
+          threadKey,
+          ...sendArgs,
+          ...args
+        });
+      } catch (t82) {
+        const error = t82;
+        setOptimistic((previous_0) => previous_0.filter((pending_0) => pending_0.id !== id));
+        throw error;
+      }
+    };
+    $[21] = durable;
+    $[22] = sendArgs;
+    $[23] = sendMutate;
+    $[24] = threadKey;
+    $[25] = t7;
+  } else {
+    t7 = $[25];
+  }
+  const send = t7;
+  let t8;
+  if ($[26] !== instanceId || $[27] !== resolveMutate || $[28] !== threadKey) {
+    t8 = async (toolCallId, note) => {
+      if (instanceId === void 0) {
+        throw new Error("useAgentChat: cannot approve — no in-flight run (thread has no instanceId)");
+      }
+      await resolveMutate({
+        decision: "approve",
+        instanceId,
+        threadKey,
+        toolCallId,
+        ...note === void 0 ? {} : {
+          note
+        }
+      });
+    };
+    $[26] = instanceId;
+    $[27] = resolveMutate;
+    $[28] = threadKey;
+    $[29] = t8;
+  } else {
+    t8 = $[29];
+  }
+  const approve = t8;
+  let t9;
+  if ($[30] !== instanceId || $[31] !== resolveMutate || $[32] !== threadKey) {
+    t9 = async (toolCallId_0, note_0) => {
+      if (instanceId === void 0) {
+        throw new Error("useAgentChat: cannot reject — no in-flight run (thread has no instanceId)");
+      }
+      await resolveMutate({
+        decision: "reject",
+        instanceId,
+        threadKey,
+        toolCallId: toolCallId_0,
+        ...note_0 === void 0 ? {} : {
+          note: note_0
+        }
+      });
+    };
+    $[30] = instanceId;
+    $[31] = resolveMutate;
+    $[32] = threadKey;
+    $[33] = t9;
+  } else {
+    t9 = $[33];
+  }
+  const reject = t9;
+  let t10;
+  if ($[34] !== cancelMutate || $[35] !== cancelReference || $[36] !== instanceId || $[37] !== threadKey) {
+    t10 = async () => {
+      if (cancelReference === void 0 || instanceId === void 0) {
+        return;
+      }
+      await cancelMutate({
+        instanceId,
+        threadKey
+      });
+    };
+    $[34] = cancelMutate;
+    $[35] = cancelReference;
+    $[36] = instanceId;
+    $[37] = threadKey;
+    $[38] = t10;
+  } else {
+    t10 = $[38];
+  }
+  const cancel = t10;
+  let t11;
+  if ($[39] !== approve || $[40] !== cancel || $[41] !== messages || $[42] !== reject || $[43] !== send || $[44] !== status || $[45] !== streamingText) {
+    t11 = {
+      approve,
+      cancel,
+      messages,
+      reject,
+      send,
+      status,
+      streamingText
+    };
+    $[39] = approve;
+    $[40] = cancel;
+    $[41] = messages;
+    $[42] = reject;
+    $[43] = send;
+    $[44] = status;
+    $[45] = streamingText;
+    $[46] = t11;
+  } else {
+    t11 = $[46];
+  }
+  return t11;
+};
+function _temp(message) {
+  return message.role === "assistant";
+}
+function _temp2(delta) {
+  return delta.text;
+}
+
+export { useAgentChat };

package/dist/packem_shared/useAgentState-Cikdlomg.mjs

@@ -0,0 +1,37 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import useSubscription from './useSubscription-D38Jdyr8.mjs';
+
+const useAgentState = (options) => {
+  const $ = c(5);
+  let t0;
+  if ($[0] !== options.threadKey) {
+    t0 = {
+      key: options.threadKey
+    };
+    $[0] = options.threadKey;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const {
+    data,
+    error
+  } = useSubscription(options.api.agents.agentState, t0);
+  const t1 = data;
+  let t2;
+  if ($[2] !== error || $[3] !== t1) {
+    t2 = {
+      error,
+      state: t1
+    };
+    $[2] = error;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  return t2;
+};
+
+export { useAgentState };

package/dist/packem_shared/useAgentToolEvents-BM7ERo00.mjs

@@ -0,0 +1,129 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useStream } from './useStream-CGC26afa.mjs';
+import useSubscription from './useSubscription-D38Jdyr8.mjs';
+
+const NO_STREAM_REF = {
+  __lunoraRef: ""
+};
+const EMPTY_MESSAGES = [];
+const toDurableEvent = (message) => {
+  if (message.role === "assistant" && message.toolCalls) {
+    return message.toolCalls.map((call) => {
+      return {
+        input: call.input,
+        seq: message.seq,
+        toolCallId: call.id,
+        toolName: call.name,
+        type: "call"
+      };
+    });
+  }
+  if (message.role !== "tool") {
+    return void 0;
+  }
+  if (message.status === "awaiting_approval") {
+    return [{
+      seq: message.seq,
+      type: "awaiting-approval",
+      ...message.toolCallId === void 0 ? {} : {
+        toolCallId: message.toolCallId
+      },
+      ...message.toolName === void 0 ? {} : {
+        toolName: message.toolName
+      }
+    }];
+  }
+  return [{
+    output: message.content,
+    seq: message.seq,
+    type: "result",
+    ...message.status === "approved" || message.status === "rejected" ? {
+      status: message.status
+    } : {},
+    ...message.toolCallId === void 0 ? {} : {
+      toolCallId: message.toolCallId
+    },
+    ...message.toolName === void 0 ? {} : {
+      toolName: message.toolName
+    }
+  }];
+};
+const useAgentToolEvents = (options) => {
+  const $ = c(12);
+  const {
+    api,
+    limit,
+    stream: streamReference,
+    threadKey
+  } = options;
+  let t0;
+  if ($[0] !== limit || $[1] !== threadKey) {
+    t0 = limit === void 0 ? {
+      key: threadKey
+    } : {
+      key: threadKey,
+      limit
+    };
+    $[0] = limit;
+    $[1] = threadKey;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const messagesArguments = t0;
+  const {
+    data: history
+  } = useSubscription(api.agents.agentMessages, messagesArguments);
+  let t1;
+  if ($[3] !== streamReference || $[4] !== threadKey) {
+    t1 = streamReference === void 0 ? "skip" : {
+      key: threadKey
+    };
+    $[3] = streamReference;
+    $[4] = threadKey;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const streamArguments = t1;
+  const {
+    chunks
+  } = useStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const durable = history ?? EMPTY_MESSAGES;
+  let events;
+  if ($[6] !== chunks || $[7] !== durable || $[8] !== threadKey) {
+    events = durable.flatMap(_temp);
+    for (const event of chunks) {
+      if (event.kind === "progress" && event.threadKey === threadKey) {
+        events.push({
+          data: event.data,
+          toolCallId: event.toolCallId,
+          type: "progress"
+        });
+      }
+    }
+    $[6] = chunks;
+    $[7] = durable;
+    $[8] = threadKey;
+    $[9] = events;
+  } else {
+    events = $[9];
+  }
+  let t2;
+  if ($[10] !== events) {
+    t2 = {
+      events
+    };
+    $[10] = events;
+    $[11] = t2;
+  } else {
+    t2 = $[11];
+  }
+  return t2;
+};
+function _temp(message) {
+  return toDurableEvent(message) ?? [];
+}
+
+export { useAgentToolEvents };